tests/phpunit/api/v3/ContributionTest.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 use Civi\Api4\Contribution;
  13
  14 /**
  15  *  Test APIv3 civicrm_contribute_* functions
  16  *
  17  * @package CiviCRM_APIv3
  18  * @subpackage API_Contribution
  19  * @group headless
  20  */
  21 class api_v3_ContributionTest extends CiviUnitTestCase {
  22
  23   use CRMTraits_Profile_ProfileTrait;
  24   use CRMTraits_Custom_CustomDataTrait;
  25
  26   protected $_individualId;
  27   protected $_contribution;
  28   protected $_financialTypeId = 1;
  29   protected $entity = 'Contribution';
  30   protected $_params;
  31   protected $_ids = [];
  32   protected $_pageParams = [];
  33   /**
  34    * Payment processor ID (dummy processor).
  35    *
  36    * @var int
  37    */
  38   protected $paymentProcessorID;
  39
  40   /**
  41    * Parameters to create payment processor.
  42    *
  43    * @var array
  44    */
  45   protected $_processorParams = [];
  46
  47   /**
  48    * ID of created event.
  49    *
  50    * @var int
  51    */
  52   protected $_eventID;
  53
  54   /**
  55    * @var CiviMailUtils
  56    */
  57   protected $mut;
  58
  59   /**
  60    * Setup function.
  61    *
  62    * @throws \CRM_Core_Exception
  63    */
  64   public function setUp() {
  65     parent::setUp();
  66
  67     $this->_apiversion = 3;
  68     $this->_individualId = $this->individualCreate();
  69     $this->_params = [
  70       'contact_id' => $this->_individualId,
  71       'receive_date' => '20120511',
  72       'total_amount' => 100.00,
  73       'financial_type_id' => $this->_financialTypeId,
  74       'non_deductible_amount' => 10.00,
  75       'fee_amount' => 5.00,
  76       'net_amount' => 95.00,
  77       'source' => 'SSF',
  78       'contribution_status_id' => 1,
  79     ];
  80     $this->_processorParams = [
  81       'domain_id' => 1,
  82       'name' => 'Dummy',
  83       'payment_processor_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Financial_BAO_PaymentProcessor', 'payment_processor_type_id', 'Dummy'),
  84       'financial_account_id' => 12,
  85       'is_active' => 1,
  86       'user_name' => '',
  87       'url_site' => 'http://dummy.com',
  88       'url_recur' => 'http://dummy.com',
  89       'billing_mode' => 1,
  90     ];
  91     $this->paymentProcessorID = $this->processorCreate();
  92     $this->_pageParams = [
  93       'title' => 'Test Contribution Page',
  94       'financial_type_id' => 1,
  95       'currency' => 'USD',
  96       'financial_account_id' => 1,
  97       'payment_processor' => $this->paymentProcessorID,
  98       'is_active' => 1,
  99       'is_allow_other_amount' => 1,
 100       'min_amount' => 10,
 101       'max_amount' => 1000,
 102     ];
 103   }
 104
 105   /**
 106    * Clean up after each test.
 107    *
 108    * @throws \CRM_Core_Exception
 109    */
 110   public function tearDown() {
 111     $this->quickCleanUpFinancialEntities();
 112     $this->quickCleanup(['civicrm_uf_match'], TRUE);
 113     $financialAccounts = $this->callAPISuccess('FinancialAccount', 'get', []);
 114     foreach ($financialAccounts['values'] as $financialAccount) {
 115       if ($financialAccount['name'] === 'Test Tax financial account ' || $financialAccount['name'] === 'Test taxable financial Type') {
 116         $entityFinancialTypes = $this->callAPISuccess('EntityFinancialAccount', 'get', [
 117           'financial_account_id' => $financialAccount['id'],
 118         ]);
 119         foreach ($entityFinancialTypes['values'] as $entityFinancialType) {
 120           $this->callAPISuccess('EntityFinancialAccount', 'delete', ['id' => $entityFinancialType['id']]);
 121         }
 122         $this->callAPISuccess('FinancialAccount', 'delete', ['id' => $financialAccount['id']]);
 123       }
 124     }
 125     $this->restoreUFGroupOne();
 126   }
 127
 128   /**
 129    * Test Get.
 130    *
 131    * @throws \CRM_Core_Exception
 132    */
 133   public function testGetContribution() {
 134     $this->enableTaxAndInvoicing();
 135     $p = [
 136       'contact_id' => $this->_individualId,
 137       'receive_date' => '2010-01-20',
 138       'total_amount' => 100.00,
 139       'financial_type_id' => $this->_financialTypeId,
 140       'non_deductible_amount' => 10.00,
 141       'fee_amount' => 5.00,
 142       'net_amount' => 95.00,
 143       'trxn_id' => 23456,
 144       'invoice_id' => 78910,
 145       'source' => 'SSF',
 146       'contribution_status_id' => 'Completed',
 147     ];
 148     $this->_contribution = $this->callAPISuccess('contribution', 'create', $p);
 149
 150     $params = [
 151       'contribution_id' => $this->_contribution['id'],
 152     ];
 153
 154     $contributions = $this->callAPIAndDocument('contribution', 'get', $params, __FUNCTION__, __FILE__);
 155     $financialParams['id'] = $this->_financialTypeId;
 156     $default = NULL;
 157     CRM_Financial_BAO_FinancialType::retrieve($financialParams, $default);
 158
 159     $this->assertEquals(1, $contributions['count']);
 160     $contribution = $contributions['values'][$contributions['id']];
 161     $this->assertEquals($contribution['contact_id'], $this->_individualId);
 162     // Note there was an assertion converting financial_type_id to 'Donation' which wasn't working.
 163     // Passing back a string rather than an id seems like an error/cruft.
 164     // If it is to be introduced we should discuss.
 165     $this->assertEquals($contribution['financial_type_id'], 1);
 166     $this->assertEquals($contribution['total_amount'], 100.00);
 167     $this->assertEquals($contribution['non_deductible_amount'], 10.00);
 168     $this->assertEquals($contribution['fee_amount'], 5.00);
 169     $this->assertEquals($contribution['net_amount'], 95.00);
 170     $this->assertEquals($contribution['trxn_id'], 23456);
 171     $this->assertEquals($contribution['invoice_id'], 78910);
 172     $this->assertEquals($contribution['invoice_number'], 'INV_' . $contributions['id']);
 173     $this->assertEquals($contribution['contribution_source'], 'SSF');
 174     $this->assertEquals($contribution['contribution_status'], 'Completed');
 175     // Create a second contribution - we are testing that 'id' gets the right contribution id (not the contact id).
 176     $p['trxn_id'] = '3847';
 177     $p['invoice_id'] = '3847';
 178
 179     $contribution2 = $this->callAPISuccess('contribution', 'create', $p);
 180
 181     // Now we have 2 - test getcount.
 182     $contribution = $this->callAPISuccess('contribution', 'getcount', []);
 183     $this->assertEquals(2, $contribution);
 184     // Test id only format.
 185     $contribution = $this->callAPISuccess('contribution', 'get', [
 186       'id' => $this->_contribution['id'],
 187       'format.only_id' => 1,
 188     ]);
 189     $this->assertEquals($this->_contribution['id'], $contribution, print_r($contribution, TRUE));
 190     // Test id only format.
 191     $contribution = $this->callAPISuccess('contribution', 'get', [
 192       'id' => $contribution2['id'],
 193       'format.only_id' => 1,
 194     ]);
 195     $this->assertEquals($contribution2['id'], $contribution);
 196     // Test id as field.
 197     $contribution = $this->callAPISuccess('contribution', 'get', [
 198       'id' => $this->_contribution['id'],
 199     ]);
 200     $this->assertEquals(1, $contribution['count']);
 201
 202     // Test get by contact id works.
 203     $contribution = $this->callAPISuccess('contribution', 'get', ['contact_id' => $this->_individualId]);
 204
 205     $this->assertEquals(2, $contribution['count']);
 206     $this->callAPISuccess('Contribution', 'Delete', [
 207       'id' => $this->_contribution['id'],
 208     ]);
 209     $this->callAPISuccess('Contribution', 'Delete', [
 210       'id' => $contribution2['id'],
 211     ]);
 212   }
 213
 214   /**
 215    * Test that test contributions can be retrieved.
 216    *
 217    * @throws \CRM_Core_Exception
 218    */
 219   public function testGetTestContribution() {
 220     $this->callAPISuccess('Contribution', 'create', array_merge($this->_params, ['is_test' => 1]));
 221     $this->callAPISuccessGetSingle('Contribution', ['is_test' => 1]);
 222   }
 223
 224   /**
 225    * Test Creating a check contribution with original check_number field
 226    */
 227   public function testCreateCheckContribution() {
 228     $params = $this->_params;
 229     $params['contribution_check_number'] = 'bouncer';
 230     $params['payment_instrument_id'] = 'Check';
 231     $params['cancel_date'] = 'yesterday';
 232     $params['receipt_date'] = 'yesterday';
 233     $params['thankyou_date'] = 'yesterday';
 234     $params['revenue_recognition_date'] = 'yesterday';
 235     $params['amount_level'] = 'Unreasonable';
 236     $params['cancel_reason'] = 'You lose sucker';
 237     $params['creditnote_id'] = 'sudo rm -rf';
 238     $params['tax_amount'] = '1';
 239     $address = $this->callAPISuccess('Address', 'create', [
 240       'street_address' => 'Knockturn Alley',
 241       'contact_id' => $this->_individualId,
 242       'location_type_id' => 'Home',
 243     ]);
 244     $params['address_id'] = $address['id'];
 245     $contributionPage = $this->contributionPageCreate();
 246     $params['contribution_page_id'] = $contributionPage['id'];
 247     $params['campaign_id'] = $this->campaignCreate();
 248     $contributionID = $this->contributionCreate($params);
 249     $getResult = $this->callAPISuccess('Contribution', 'get', ['id' => $contributionID]);
 250     $this->assertEquals('bouncer', $getResult['values'][$contributionID]['check_number']);
 251     $entityFinancialTrxn = $this->callAPISuccess('EntityFinancialTrxn', 'get', ['entity_id' => $contributionID, 'entity_table' => 'civicrm_contribution']);
 252     foreach ($entityFinancialTrxn['values'] as $eft) {
 253       $financialTrxn = $this->callAPISuccess('FinancialTrxn', 'get', ['id' => $eft['financial_trxn_id']]);
 254       $this->assertEquals('bouncer', $financialTrxn['values'][$financialTrxn['id']]['check_number']);
 255     }
 256   }
 257
 258   /**
 259    * Test the 'return' param works for all fields.
 260    *
 261    * @throws \CRM_Core_Exception
 262    */
 263   public function testGetContributionReturnFunctionality() {
 264     $params = $this->_params;
 265     $params['contribution_check_number'] = 'bouncer';
 266     $params['payment_instrument_id'] = 'Check';
 267     $params['cancel_date'] = 'yesterday';
 268     $params['receipt_date'] = 'yesterday';
 269     $params['thankyou_date'] = 'yesterday';
 270     $params['revenue_recognition_date'] = 'yesterday';
 271     $params['amount_level'] = 'Unreasonable';
 272     $params['cancel_reason'] = 'You lose sucker';
 273     $params['creditnote_id'] = 'sudo rm -rf';
 274     $params['tax_amount'] = '1';
 275     $address = $this->callAPISuccess('Address', 'create', [
 276       'street_address' => 'Knockturn Alley',
 277       'contact_id' => $this->_individualId,
 278       'location_type_id' => 'Home',
 279     ]);
 280     $params['address_id'] = $address['id'];
 281     $contributionPage = $this->contributionPageCreate();
 282     $params['contribution_page_id'] = $contributionPage['id'];
 283     $contributionRecur = $this->callAPISuccess('ContributionRecur', 'create', [
 284       'contact_id' => $this->_individualId,
 285       'frequency_interval' => 1,
 286       'amount' => 5,
 287     ]);
 288     $params['contribution_recur_id'] = $contributionRecur['id'];
 289
 290     $params['campaign_id'] = $this->campaignCreate();
 291
 292     $contributionID = $this->contributionCreate($params);
 293
 294     // update contribution with invoice number
 295     $params = array_merge($params, [
 296       'id' => $contributionID,
 297       'invoice_number' => CRM_Utils_Array::value('invoice_prefix', Civi::settings()->get('contribution_invoice_settings')) . "" . $contributionID,
 298       'trxn_id' => 12345,
 299       'invoice_id' => 6789,
 300     ]);
 301     $contributionID = $this->contributionCreate($params);
 302
 303     $contribution = $this->callAPISuccessGetSingle('Contribution', ['id' => $contributionID]);
 304     $this->assertEquals('bouncer', $contribution['check_number']);
 305     $this->assertEquals('bouncer', $contribution['contribution_check_number']);
 306
 307     $fields = CRM_Contribute_BAO_Contribution::fields();
 308     // Re-add these 2 to the fields to check. They were locked in but the metadata changed so we
 309     // need to specify them.
 310     $fields['address_id'] = $fields['contribution_address_id'];
 311     $fields['check_number'] = $fields['contribution_check_number'];
 312
 313     $fieldsLockedIn = [
 314       'contribution_id', 'contribution_contact_id', 'financial_type_id', 'contribution_page_id',
 315       'payment_instrument_id', 'receive_date', 'non_deductible_amount', 'total_amount',
 316       'fee_amount', 'net_amount', 'trxn_id', 'invoice_id', 'currency', 'contribution_cancel_date', 'cancel_reason',
 317       'receipt_date', 'thankyou_date', 'contribution_source', 'amount_level', 'contribution_recur_id',
 318       'is_test', 'is_pay_later', 'contribution_status_id', 'address_id', 'check_number', 'contribution_campaign_id',
 319       'creditnote_id', 'tax_amount', 'revenue_recognition_date', 'decoy',
 320     ];
 321     $missingFields = array_diff($fieldsLockedIn, array_keys($fields));
 322     // If any of the locked in fields disappear from the $fields array we need to make sure it is still
 323     // covered as the test contract now guarantees them in the return array.
 324     $this->assertEquals($missingFields, [29 => 'decoy'], 'A field which was covered by the test contract has changed.');
 325     foreach ($fields as $fieldName => $fieldSpec) {
 326       $contribution = $this->callAPISuccessGetSingle('Contribution', ['id' => $contributionID, 'return' => $fieldName]);
 327       $returnField = $fieldName;
 328       if ($returnField == 'contribution_contact_id') {
 329         $returnField = 'contact_id';
 330       }
 331       $this->assertTrue((!empty($contribution[$returnField]) || $contribution[$returnField] === "0"), $returnField);
 332     }
 333     $entityFinancialTrxn = $this->callAPISuccess('EntityFinancialTrxn', 'get', ['entity_id' => $contributionID, 'entity_table' => 'civicrm_contribution']);
 334     foreach ($entityFinancialTrxn['values'] as $eft) {
 335       $financialTrxn = $this->callAPISuccess('FinancialTrxn', 'get', ['id' => $eft['financial_trxn_id']]);
 336       $this->assertEquals('bouncer', $financialTrxn['values'][$financialTrxn['id']]['check_number']);
 337     }
 338   }
 339
 340   /**
 341    * Test cancel reason works as a filter.
 342    */
 343   public function testFilterCancelReason() {
 344     $params = $this->_params;
 345     $params['cancel_date'] = 'yesterday';
 346     $params['cancel_reason'] = 'You lose sucker';
 347     $this->callAPISuccess('Contribution', 'create', $params);
 348     $params = $this->_params;
 349     $params['cancel_date'] = 'yesterday';
 350     $params['cancel_reason'] = 'You are a winner';
 351     $this->callAPISuccess('Contribution', 'create', $params);
 352     $this->callAPISuccessGetCount('Contribution', ['cancel_reason' => 'You are a winner'], 1);
 353   }
 354
 355   /**
 356    * We need to ensure previous tested behaviour still works as part of the api contract.
 357    */
 358   public function testGetContributionLegacyBehaviour() {
 359     $p = [
 360       'contact_id' => $this->_individualId,
 361       'receive_date' => '2010-01-20',
 362       'total_amount' => 100.00,
 363       'contribution_type_id' => $this->_financialTypeId,
 364       'non_deductible_amount' => 10.00,
 365       'fee_amount' => 5.00,
 366       'net_amount' => 95.00,
 367       'trxn_id' => 23456,
 368       'invoice_id' => 78910,
 369       'source' => 'SSF',
 370       'contribution_status_id' => 1,
 371     ];
 372     $this->_contribution = $this->callAPISuccess('Contribution', 'create', $p);
 373
 374     $params = [
 375       'contribution_id' => $this->_contribution['id'],
 376     ];
 377     $contribution = $this->callAPISuccess('contribution', 'get', $params);
 378     $financialParams['id'] = $this->_financialTypeId;
 379     $default = NULL;
 380     CRM_Financial_BAO_FinancialType::retrieve($financialParams, $default);
 381
 382     $this->assertEquals(1, $contribution['count']);
 383     $this->assertEquals($contribution['values'][$contribution['id']]['contact_id'], $this->_individualId);
 384     $this->assertEquals($contribution['values'][$contribution['id']]['financial_type_id'], $this->_financialTypeId);
 385     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_type_id'], $this->_financialTypeId);
 386     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
 387     $this->assertEquals($contribution['values'][$contribution['id']]['non_deductible_amount'], 10.00);
 388     $this->assertEquals($contribution['values'][$contribution['id']]['fee_amount'], 5.00);
 389     $this->assertEquals($contribution['values'][$contribution['id']]['net_amount'], 95.00);
 390     $this->assertEquals($contribution['values'][$contribution['id']]['trxn_id'], 23456);
 391     $this->assertEquals($contribution['values'][$contribution['id']]['invoice_id'], 78910);
 392     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_source'], 'SSF');
 393     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_status'], 'Completed');
 394
 395     // Create a second contribution - we are testing that 'id' gets the right contribution id (not the contact id).
 396     $p['trxn_id'] = '3847';
 397     $p['invoice_id'] = '3847';
 398
 399     $contribution2 = $this->callAPISuccess('contribution', 'create', $p);
 400
 401     // now we have 2 - test getcount
 402     $contribution = $this->callAPISuccess('contribution', 'getcount', []);
 403     $this->assertEquals(2, $contribution);
 404     //test id only format
 405     $contribution = $this->callAPISuccess('contribution', 'get', [
 406       'id' => $this->_contribution['id'],
 407       'format.only_id' => 1,
 408     ]);
 409     $this->assertEquals($this->_contribution['id'], $contribution, print_r($contribution, TRUE));
 410     //test id only format
 411     $contribution = $this->callAPISuccess('contribution', 'get', [
 412       'id' => $contribution2['id'],
 413       'format.only_id' => 1,
 414     ]);
 415     $this->assertEquals($contribution2['id'], $contribution);
 416     $contribution = $this->callAPISuccess('contribution', 'get', [
 417       'id' => $this->_contribution['id'],
 418     ]);
 419     //test id as field
 420     $this->assertEquals(1, $contribution['count']);
 421     // $this->assertEquals($this->_contribution['id'], $contribution['id'] )  ;
 422     //test get by contact id works
 423     $contribution = $this->callAPISuccess('contribution', 'get', ['contact_id' => $this->_individualId]);
 424
 425     $this->assertEquals(2, $contribution['count']);
 426     $this->callAPISuccess('Contribution', 'Delete', [
 427       'id' => $this->_contribution['id'],
 428     ]);
 429     $this->callAPISuccess('Contribution', 'Delete', [
 430       'id' => $contribution2['id'],
 431     ]);
 432   }
 433
 434   /**
 435    * Create an contribution_id=FALSE and financial_type_id=Donation.
 436    */
 437   public function testCreateEmptyContributionIDUseDonation() {
 438     $params = [
 439       'contribution_id' => FALSE,
 440       'contact_id' => 1,
 441       'total_amount' => 1,
 442       'check_permissions' => FALSE,
 443       'financial_type_id' => 'Donation',
 444     ];
 445     $this->callAPISuccess('contribution', 'create', $params);
 446   }
 447
 448   /**
 449    * Check with complete array + custom field.
 450    *
 451    * Note that the test is written on purpose without any
 452    * variables specific to participant so it can be replicated into other entities
 453    * and / or moved to the automated test suite
 454    *
 455    * @throws \CRM_Core_Exception
 456    */
 457   public function testCreateWithCustom() {
 458     $ids = $this->entityCustomGroupWithSingleFieldCreate(__FUNCTION__, __FILE__);
 459
 460     $params = $this->_params;
 461     $params['custom_' . $ids['custom_field_id']] = "custom string";
 462
 463     $result = $this->callAPIAndDocument($this->entity, 'create', $params, __FUNCTION__, __FILE__);
 464     $this->assertEquals($result['id'], $result['values'][$result['id']]['id']);
 465     $check = $this->callAPISuccess($this->entity, 'get', [
 466       'return.custom_' . $ids['custom_field_id'] => 1,
 467       'id' => $result['id'],
 468     ]);
 469     $group = $this->callAPISuccess('CustomGroup', 'getsingle', ['id' => $ids['custom_group_id']]);
 470     $field = $this->callAPISuccess('CustomField', 'getsingle', ['id' => $ids['custom_field_id']]);
 471     $contribution = \Civi\Api4\Contribution::get()
 472       ->setSelect([
 473         'id',
 474         'total_amount',
 475         $group['name'] . '.' . $field['name'],
 476       ])
 477       ->addWhere('id', '=', $result['id'])
 478       ->execute()
 479       ->first();
 480     $this->customFieldDelete($ids['custom_field_id']);
 481     $this->customGroupDelete($ids['custom_group_id']);
 482     $this->assertEquals('custom string', $check['values'][$check['id']]['custom_' . $ids['custom_field_id']]);
 483   }
 484
 485   /**
 486    * Check with complete array + custom field.
 487    *
 488    * Note that the test is written on purpose without any
 489    * variables specific to participant so it can be replicated into other entities
 490    * and / or moved to the automated test suite
 491    */
 492   public function testCreateGetFieldsWithCustom() {
 493     $ids = $this->entityCustomGroupWithSingleFieldCreate(__FUNCTION__, __FILE__);
 494     $idsContact = $this->entityCustomGroupWithSingleFieldCreate(__FUNCTION__, 'ContactTest.php');
 495     $result = $this->callAPISuccess('Contribution', 'getfields', []);
 496     $this->assertArrayHasKey('custom_' . $ids['custom_field_id'], $result['values']);
 497     $this->assertArrayNotHasKey('custom_' . $idsContact['custom_field_id'], $result['values']);
 498     $this->customFieldDelete($ids['custom_field_id']);
 499     $this->customGroupDelete($ids['custom_group_id']);
 500     $this->customFieldDelete($idsContact['custom_field_id']);
 501     $this->customGroupDelete($idsContact['custom_group_id']);
 502   }
 503
 504   public function testCreateContributionNoLineItems() {
 505
 506     $params = [
 507       'contact_id' => $this->_individualId,
 508       'receive_date' => '20120511',
 509       'total_amount' => 100.00,
 510       'financial_type_id' => $this->_financialTypeId,
 511       'payment_instrument_id' => 1,
 512       'non_deductible_amount' => 10.00,
 513       'fee_amount' => 50.00,
 514       'net_amount' => 90.00,
 515       'trxn_id' => 12345,
 516       'invoice_id' => 67890,
 517       'source' => 'SSF',
 518       'contribution_status_id' => 1,
 519       'skipLineItem' => 1,
 520     ];
 521
 522     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 523     $financialItems = $this->callAPISuccess('FinancialItem', 'get', []);
 524     foreach ($financialItems['values'] as $financialItem) {
 525       $this->assertEquals(date('Y-m-d H:i:s', strtotime($contribution['values'][$contribution['id']]['receive_date'])), date('Y-m-d H:i:s', strtotime($financialItem['transaction_date'])));
 526     }
 527     $lineItems = $this->callAPISuccess('line_item', 'get', [
 528       'entity_id' => $contribution['id'],
 529       'entity_table' => 'civicrm_contribution',
 530       'sequential' => 1,
 531     ]);
 532     $this->assertEquals(0, $lineItems['count']);
 533   }
 534
 535   /**
 536    * Test checks that passing in line items suppresses the create mechanism.
 537    */
 538   public function testCreateContributionChainedLineItems() {
 539     $params = [
 540       'contact_id' => $this->_individualId,
 541       'receive_date' => '20120511',
 542       'total_amount' => 100.00,
 543       'financial_type_id' => $this->_financialTypeId,
 544       'payment_instrument_id' => 1,
 545       'non_deductible_amount' => 10.00,
 546       'fee_amount' => 50.00,
 547       'net_amount' => 90.00,
 548       'trxn_id' => 12345,
 549       'invoice_id' => 67890,
 550       'source' => 'SSF',
 551       'contribution_status_id' => 1,
 552       'skipLineItem' => 1,
 553       'api.line_item.create' => [
 554         [
 555           'price_field_id' => 1,
 556           'qty' => 2,
 557           'line_total' => '20',
 558           'unit_price' => '10',
 559         ],
 560         [
 561           'price_field_id' => 1,
 562           'qty' => 1,
 563           'line_total' => '80',
 564           'unit_price' => '80',
 565         ],
 566       ],
 567     ];
 568
 569     $description = "Create Contribution with Nested Line Items.";
 570     $subfile = "CreateWithNestedLineItems";
 571     $contribution = $this->callAPIAndDocument('contribution', 'create', $params, __FUNCTION__, __FILE__, $description, $subfile);
 572
 573     $lineItems = $this->callAPISuccess('line_item', 'get', [
 574       'entity_id' => $contribution['id'],
 575       'contribution_id' => $contribution['id'],
 576       'entity_table' => 'civicrm_contribution',
 577       'sequential' => 1,
 578     ]);
 579     $this->assertEquals(2, $lineItems['count']);
 580   }
 581
 582   public function testCreateContributionOffline() {
 583     $params = [
 584       'contact_id' => $this->_individualId,
 585       'receive_date' => '20120511',
 586       'total_amount' => 100.00,
 587       'financial_type_id' => 1,
 588       'trxn_id' => 12345,
 589       'invoice_id' => 67890,
 590       'source' => 'SSF',
 591       'contribution_status_id' => 1,
 592     ];
 593
 594     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 595     $this->assertEquals($contribution['values'][$contribution['id']]['contact_id'], $this->_individualId);
 596     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
 597     $this->assertEquals($contribution['values'][$contribution['id']]['financial_type_id'], 1);
 598     $this->assertEquals($contribution['values'][$contribution['id']]['trxn_id'], 12345);
 599     $this->assertEquals($contribution['values'][$contribution['id']]['invoice_id'], 67890);
 600     $this->assertEquals($contribution['values'][$contribution['id']]['source'], 'SSF');
 601     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_status_id'], 1);
 602     $lineItems = $this->callAPISuccess('line_item', 'get', [
 603       'entity_id' => $contribution['id'],
 604       'contribution_id' => $contribution['id'],
 605       'entity_table' => 'civicrm_contribution',
 606       'sequential' => 1,
 607     ]);
 608     $this->assertEquals(1, $lineItems['count']);
 609     $this->assertEquals($contribution['id'], $lineItems['values'][0]['entity_id']);
 610     $this->assertEquals($contribution['id'], $lineItems['values'][0]['contribution_id']);
 611     $this->_checkFinancialRecords($contribution, 'offline');
 612     $this->contributionGetnCheck($params, $contribution['id']);
 613   }
 614
 615   /**
 616    * Test create with valid payment instrument.
 617    */
 618   public function testCreateContributionWithPaymentInstrument() {
 619     $params = $this->_params + ['payment_instrument' => 'EFT'];
 620     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 621     $contribution = $this->callAPISuccess('contribution', 'get', [
 622       'sequential' => 1,
 623       'id' => $contribution['id'],
 624     ]);
 625     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 626     $this->assertEquals('EFT', $contribution['values'][0]['payment_instrument']);
 627
 628     $this->callAPISuccess('contribution', 'create', [
 629       'id' => $contribution['id'],
 630       'payment_instrument' => 'Credit Card',
 631     ]);
 632     $contribution = $this->callAPISuccess('contribution', 'get', [
 633       'sequential' => 1,
 634       'id' => $contribution['id'],
 635     ]);
 636     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 637     $this->assertEquals('Credit Card', $contribution['values'][0]['payment_instrument']);
 638   }
 639
 640   public function testGetContributionByPaymentInstrument() {
 641     $params = $this->_params + ['payment_instrument' => 'EFT'];
 642     $params2 = $this->_params + ['payment_instrument' => 'Cash'];
 643     $this->callAPISuccess('contribution', 'create', $params);
 644     $this->callAPISuccess('contribution', 'create', $params2);
 645     $contribution = $this->callAPISuccess('contribution', 'get', [
 646       'sequential' => 1,
 647       'contribution_payment_instrument' => 'Cash',
 648     ]);
 649     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 650     $this->assertEquals('Cash', $contribution['values'][0]['payment_instrument']);
 651     $this->assertEquals(1, $contribution['count']);
 652     $contribution = $this->callAPISuccess('contribution', 'get', ['sequential' => 1, 'payment_instrument' => 'Cash']);
 653     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 654     $this->assertEquals('Cash', $contribution['values'][0]['payment_instrument']);
 655     $this->assertEquals(1, $contribution['count']);
 656     $contribution = $this->callAPISuccess('contribution', 'get', [
 657       'sequential' => 1,
 658       'payment_instrument_id' => 5,
 659     ]);
 660     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 661     $this->assertEquals('EFT', $contribution['values'][0]['payment_instrument']);
 662     $this->assertEquals(1, $contribution['count']);
 663     $contribution = $this->callAPISuccess('contribution', 'get', [
 664       'sequential' => 1,
 665       'payment_instrument' => 'EFT',
 666     ]);
 667     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 668     $this->assertEquals('EFT', $contribution['values'][0]['payment_instrument']);
 669     $this->assertEquals(1, $contribution['count']);
 670     $contribution = $this->callAPISuccess('contribution', 'create', [
 671       'id' => $contribution['id'],
 672       'payment_instrument' => 'Credit Card',
 673     ]);
 674     $contribution = $this->callAPISuccess('contribution', 'get', ['sequential' => 1, 'id' => $contribution['id']]);
 675     $this->assertArrayHasKey('payment_instrument', $contribution['values'][0]);
 676     $this->assertEquals('Credit Card', $contribution['values'][0]['payment_instrument']);
 677     $this->assertEquals(1, $contribution['count']);
 678   }
 679
 680   /**
 681    * CRM-16227 introduces invoice_id as a parameter.
 682    */
 683   public function testGetContributionByInvoice() {
 684     $this->callAPISuccess('Contribution', 'create', array_merge($this->_params, ['invoice_id' => 'curly']));
 685     $this->callAPISuccess('Contribution', 'create', array_merge($this->_params), ['invoice_id' => 'churlish']);
 686     $this->callAPISuccessGetCount('Contribution', [], 2);
 687     $this->callAPISuccessGetSingle('Contribution', ['invoice_id' => 'curly']);
 688     // The following don't work. They are the format we are trying to introduce but although the form uses this format
 689     // CRM_Contact_BAO_Query::convertFormValues puts them into the other format & the where only supports that.
 690     // ideally the where clause would support this format (as it does on contact_BAO_Query) and those lines would
 691     // come out of convertFormValues
 692     // $this->callAPISuccessGetSingle('Contribution', array('invoice_id' => array('LIKE' => '%ish%')));
 693     // $this->callAPISuccessGetSingle('Contribution', array('invoice_id' => array('NOT IN' => array('curly'))));
 694     // $this->callAPISuccessGetCount('Contribution', array('invoice_id' => array('LIKE' => '%ly%')), 2);
 695     // $this->callAPISuccessGetCount('Contribution', array('invoice_id' => array('IN' => array('curly', 'churlish'))),
 696     // 2);
 697   }
 698
 699   /**
 700    * Check the credit note retrieval is case insensitive.
 701    */
 702   public function testGetCreditNoteCaseInsensitive() {
 703     $this->contributionCreate(['contact_id' => $this->_individualId]);
 704     $this->contributionCreate(['creditnote_id' => 'cN1234', 'contact_id' => $this->_individualId, 'invoice_id' => rand(), 'trxn_id' => rand()]);
 705     $contribution = $this->callAPISuccess('Contribution', 'getsingle', ['creditnote_id' => 'CN1234']);
 706     $this->assertEquals($contribution['creditnote_id'], 'cN1234');
 707   }
 708
 709   /**
 710    * Test retrieval by total_amount works.
 711    *
 712    * @throws Exception
 713    */
 714   public function testGetContributionByTotalAmount() {
 715     $this->callAPISuccess('Contribution', 'create', array_merge($this->_params, ['total_amount' => '5']));
 716     $this->callAPISuccess('Contribution', 'create', array_merge($this->_params, ['total_amount' => '10']));
 717     $this->callAPISuccessGetCount('Contribution', ['total_amount' => 10], 1);
 718     $this->callAPISuccessGetCount('Contribution', ['total_amount' => ['>' => 6]], 1);
 719     $this->callAPISuccessGetCount('Contribution', ['total_amount' => ['>' => 0]], 2);
 720     $this->callAPISuccessGetCount('Contribution', ['total_amount' => ['>' => -5]], 2);
 721     $this->callAPISuccessGetCount('Contribution', ['total_amount' => ['<' => 0]], 0);
 722     $this->callAPISuccessGetCount('Contribution', [], 2);
 723   }
 724
 725   /**
 726    * @dataProvider createLocalizedContributionDataProvider
 727    * @param $totalAmount
 728    * @param $decimalPoint
 729    * @param $thousandSeparator
 730    * @param $currency
 731    * @param $expectedResult
 732    * @throws \Exception
 733    */
 734   public function testCreateLocalizedContribution($totalAmount, $decimalPoint, $thousandSeparator, $currency, $expectedResult) {
 735     $this->setDefaultCurrency($currency);
 736     $this->setMonetaryDecimalPoint($decimalPoint);
 737     $this->setMonetaryThousandSeparator($thousandSeparator);
 738
 739     $_params = [
 740       'contact_id' => $this->_individualId,
 741       'receive_date' => '20120511',
 742       'total_amount' => $totalAmount,
 743       'financial_type_id' => $this->_financialTypeId,
 744       'contribution_status_id' => 1,
 745     ];
 746
 747     if ($expectedResult) {
 748       $this->callAPISuccess('Contribution', 'create', $_params);
 749     }
 750     else {
 751       $this->callAPIFailure('Contribution', 'create', $_params);
 752     }
 753   }
 754
 755   /**
 756    * @return array
 757    */
 758   public function createLocalizedContributionDataProvider() {
 759     return [
 760       [10, '.', ',', 'USD', TRUE],
 761       ['145.0E+3', '.', ',', 'USD', FALSE],
 762       ['10', '.', ',', 'USD', TRUE],
 763       [-10, '.', ',', 'USD', TRUE],
 764       ['-10', '.', ',', 'USD', TRUE],
 765       ['-10foo', '.', ',', 'USD', FALSE],
 766       ['-10.0345619', '.', ',', 'USD', TRUE],
 767       ['-10.010,4345619', '.', ',', 'USD', TRUE],
 768       ['10.0104345619', '.', ',', 'USD', TRUE],
 769       ['-0', '.', ',', 'USD', TRUE],
 770       ['-.1', '.', ',', 'USD', TRUE],
 771       ['.1', '.', ',', 'USD', TRUE],
 772       // Test currency symbols too, default locale uses $, so if we wanted to test others we'd need to reconfigure locale
 773       ['$1,234,567.89', '.', ',', 'USD', TRUE],
 774       ['-$1,234,567.89', '.', ',', 'USD', TRUE],
 775       ['$-1,234,567.89', '.', ',', 'USD', TRUE],
 776       // This is the float format. Encapsulated in strings
 777       ['1234567.89', '.', ',', 'USD', TRUE],
 778       // This is the float format.
 779       [1234567.89, '.', ',', 'USD', TRUE],
 780       // Test EURO currency
 781       ['€1,234,567.89', '.', ',', 'EUR', TRUE],
 782       ['-€1,234,567.89', '.', ',', 'EUR', TRUE],
 783       ['€-1,234,567.89', '.', ',', 'EUR', TRUE],
 784       // This is the float format. Encapsulated in strings
 785       ['1234567.89', '.', ',', 'EUR', TRUE],
 786       // This is the float format.
 787       [1234567.89, '.', ',', 'EUR', TRUE],
 788       // Test Norwegian KR currency
 789       ['kr1,234,567.89', '.', ',', 'NOK', TRUE],
 790       ['kr 1,234,567.89', '.', ',', 'NOK', TRUE],
 791       ['-kr1,234,567.89', '.', ',', 'NOK', TRUE],
 792       ['-kr 1,234,567.89', '.', ',', 'NOK', TRUE],
 793       ['kr-1,234,567.89', '.', ',', 'NOK', TRUE],
 794       ['kr -1,234,567.89', '.', ',', 'NOK', TRUE],
 795       // This is the float format. Encapsulated in strings
 796       ['1234567.89', '.', ',', 'NOK', TRUE],
 797       // This is the float format.
 798       [1234567.89, '.', ',', 'NOK', TRUE],
 799       // Test different localization options: , as decimal separator and dot as thousand separator
 800       ['$1.234.567,89', ',', '.', 'USD', TRUE],
 801       ['-$1.234.567,89', ',', '.', 'USD', TRUE],
 802       ['$-1.234.567,89', ',', '.', 'USD', TRUE],
 803       ['1.234.567,89', ',', '.', 'USD', TRUE],
 804       // This is the float format. Encapsulated in strings
 805       ['1234567.89', ',', '.', 'USD', TRUE],
 806       // This is the float format.
 807       [1234567.89, ',', '.', 'USD', TRUE],
 808       ['$1,234,567.89', ',', '.', 'USD', FALSE],
 809       ['-$1,234,567.89', ',', '.', 'USD', FALSE],
 810       ['$-1,234,567.89', ',', '.', 'USD', FALSE],
 811       // Now with a space as thousand separator
 812       ['$1 234 567,89', ',', ' ', 'USD', TRUE],
 813       ['-$1 234 567,89', ',', ' ', 'USD', TRUE],
 814       ['$-1 234 567,89', ',', ' ', 'USD', TRUE],
 815       ['1 234 567,89', ',', ' ', 'USD', TRUE],
 816       // This is the float format. Encapsulated in strings
 817       ['1234567.89', ',', ' ', 'USD', TRUE],
 818       // This is the float format.
 819       [1234567.89, ',', ' ', 'USD', TRUE],
 820     ];
 821   }
 822
 823   /**
 824    * Create test with unique field name on source.
 825    */
 826   public function testCreateContributionSource() {
 827
 828     $params = [
 829       'contact_id' => $this->_individualId,
 830       'receive_date' => date('Ymd'),
 831       'total_amount' => 100.00,
 832       'financial_type_id' => $this->_financialTypeId,
 833       'payment_instrument_id' => 1,
 834       'non_deductible_amount' => 10.00,
 835       'fee_amount' => 50.00,
 836       'net_amount' => 90.00,
 837       'trxn_id' => 12345,
 838       'invoice_id' => 67890,
 839       'contribution_source' => 'SSF',
 840       'contribution_status_id' => 1,
 841     ];
 842
 843     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 844     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
 845     $this->assertEquals($contribution['values'][$contribution['id']]['source'], 'SSF');
 846   }
 847
 848   /**
 849    * Create test with unique field name on source.
 850    *
 851    * @param string $thousandSeparator
 852    *   punctuation used to refer to thousands.
 853    *
 854    * @dataProvider getThousandSeparators
 855    */
 856   public function testCreateDefaultNow($thousandSeparator) {
 857     $this->setCurrencySeparators($thousandSeparator);
 858     $params = $this->_params;
 859     unset($params['receive_date'], $params['net_amount']);
 860
 861     $params['total_amount'] = $this->formatMoneyInput(5000.77);
 862     $params['fee_amount'] = $this->formatMoneyInput(.77);
 863     $params['skipCleanMoney'] = FALSE;
 864
 865     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 866     $contribution = $this->callAPISuccessGetSingle('contribution', ['id' => $contribution['id']]);
 867     $this->assertEquals(date('Y-m-d'), date('Y-m-d', strtotime($contribution['receive_date'])));
 868     $this->assertEquals(5000.77, $contribution['total_amount'], 'failed to handle ' . $this->formatMoneyInput(5000.77));
 869     $this->assertEquals(.77, $contribution['fee_amount']);
 870     $this->assertEquals(5000, $contribution['net_amount']);
 871   }
 872
 873   /**
 874    * Create test with unique field name on source.
 875    */
 876   public function testCreateContributionNullOutThankyouDate() {
 877
 878     $params = $this->_params;
 879     $params['thankyou_date'] = 'yesterday';
 880
 881     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 882     $contribution = $this->callAPISuccessGetSingle('contribution', ['id' => $contribution['id']]);
 883     $this->assertEquals(date('Y-m-d', strtotime('yesterday')), date('Y-m-d', strtotime($contribution['thankyou_date'])));
 884
 885     $params['thankyou_date'] = 'null';
 886     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 887     $contribution = $this->assertTrue(empty($contribution['thankyou_date']));
 888   }
 889
 890   /**
 891    * Create test with unique field name on source.
 892    */
 893   public function testCreateContributionSourceInvalidContact() {
 894
 895     $params = [
 896       'contact_id' => 999,
 897       'receive_date' => date('Ymd'),
 898       'total_amount' => 100.00,
 899       'financial_type_id' => $this->_financialTypeId,
 900       'payment_instrument_id' => 1,
 901       'non_deductible_amount' => 10.00,
 902       'fee_amount' => 50.00,
 903       'net_amount' => 90.00,
 904       'trxn_id' => 12345,
 905       'invoice_id' => 67890,
 906       'contribution_source' => 'SSF',
 907       'contribution_status_id' => 1,
 908     ];
 909
 910     $this->callAPIFailure('contribution', 'create', $params, 'contact_id is not valid : 999');
 911   }
 912
 913   public function testCreateContributionSourceInvalidContContact() {
 914
 915     $params = [
 916       'contribution_contact_id' => 999,
 917       'receive_date' => date('Ymd'),
 918       'total_amount' => 100.00,
 919       'financial_type_id' => $this->_financialTypeId,
 920       'payment_instrument_id' => 1,
 921       'non_deductible_amount' => 10.00,
 922       'fee_amount' => 50.00,
 923       'net_amount' => 90.00,
 924       'trxn_id' => 12345,
 925       'invoice_id' => 67890,
 926       'contribution_source' => 'SSF',
 927       'contribution_status_id' => 1,
 928     ];
 929
 930     $this->callAPIFailure('contribution', 'create', $params);
 931   }
 932
 933   /**
 934    * Test note created correctly.
 935    */
 936   public function testCreateContributionWithNote() {
 937     $description = "Demonstrates creating contribution with Note Entity.";
 938     $subfile = "ContributionCreateWithNote";
 939     $params = [
 940       'contact_id' => $this->_individualId,
 941       'receive_date' => '2012-01-01',
 942       'total_amount' => 100.00,
 943       'financial_type_id' => $this->_financialTypeId,
 944       'payment_instrument_id' => 1,
 945       'non_deductible_amount' => 10.00,
 946       'fee_amount' => 50.00,
 947       'net_amount' => 90.00,
 948       'trxn_id' => 12345,
 949       'invoice_id' => 67890,
 950       'source' => 'SSF',
 951       'contribution_status_id' => 1,
 952       'note' => 'my contribution note',
 953     ];
 954
 955     $contribution = $this->callAPIAndDocument('contribution', 'create', $params, __FUNCTION__, __FILE__, $description, $subfile);
 956     $result = $this->callAPISuccess('note', 'get', [
 957       'entity_table' => 'civicrm_contribution',
 958       'entity_id' => $contribution['id'],
 959       'sequential' => 1,
 960     ]);
 961     $this->assertEquals('my contribution note', $result['values'][0]['note']);
 962     $this->callAPISuccess('contribution', 'delete', ['id' => $contribution['id']]);
 963   }
 964
 965   public function testCreateContributionWithNoteUniqueNameAliases() {
 966     $params = [
 967       'contact_id' => $this->_individualId,
 968       'receive_date' => '2012-01-01',
 969       'total_amount' => 100.00,
 970       'financial_type_id' => $this->_financialTypeId,
 971       'payment_instrument_id' => 1,
 972       'non_deductible_amount' => 10.00,
 973       'fee_amount' => 50.00,
 974       'net_amount' => 90.00,
 975       'trxn_id' => 12345,
 976       'invoice_id' => 67890,
 977       'source' => 'SSF',
 978       'contribution_status_id' => 1,
 979       'contribution_note' => 'my contribution note',
 980     ];
 981
 982     $contribution = $this->callAPISuccess('contribution', 'create', $params);
 983     $result = $this->callAPISuccess('note', 'get', [
 984       'entity_table' => 'civicrm_contribution',
 985       'entity_id' => $contribution['id'],
 986       'sequential' => 1,
 987     ]);
 988     $this->assertEquals('my contribution note', $result['values'][0]['note']);
 989     $this->callAPISuccess('contribution', 'delete', ['id' => $contribution['id']]);
 990   }
 991
 992   /**
 993    * This is the test for creating soft credits.
 994    */
 995   public function testCreateContributionWithSoftCredit() {
 996     $description = "Demonstrates creating contribution with SoftCredit.";
 997     $subfile = "ContributionCreateWithSoftCredit";
 998     $contact2 = $this->callAPISuccess('Contact', 'create', [
 999       'display_name' => 'superman',
1000       'contact_type' => 'Individual',
1001     ]);
1002     $softParams = [
1003       'contact_id' => $contact2['id'],
1004       'amount' => 50,
1005       'soft_credit_type_id' => 3,
1006     ];
1007
1008     $params = $this->_params + ['soft_credit' => [1 => $softParams]];
1009     $contribution = $this->callAPIAndDocument('contribution', 'create', $params, __FUNCTION__, __FILE__, $description, $subfile);
1010     $result = $this->callAPISuccess('contribution', 'get', ['return' => 'soft_credit', 'sequential' => 1]);
1011
1012     $this->assertEquals($softParams['contact_id'], $result['values'][0]['soft_credit'][1]['contact_id']);
1013     $this->assertEquals($softParams['amount'], $result['values'][0]['soft_credit'][1]['amount']);
1014     $this->assertEquals($softParams['soft_credit_type_id'], $result['values'][0]['soft_credit'][1]['soft_credit_type']);
1015
1016     $this->callAPISuccess('contribution', 'delete', ['id' => $contribution['id']]);
1017     $this->callAPISuccess('contact', 'delete', ['id' => $contact2['id']]);
1018   }
1019
1020   public function testCreateContributionWithSoftCreditDefaults() {
1021     $description = "Demonstrates creating contribution with Soft Credit defaults for amount and type.";
1022     $subfile = "ContributionCreateWithSoftCreditDefaults";
1023     $contact2 = $this->callAPISuccess('Contact', 'create', [
1024       'display_name' => 'superman',
1025       'contact_type' => 'Individual',
1026     ]);
1027     $params = $this->_params + [
1028       'soft_credit_to' => $contact2['id'],
1029     ];
1030     $contribution = $this->callAPIAndDocument('contribution', 'create', $params, __FUNCTION__, __FILE__, $description, $subfile);
1031     $result = $this->callAPISuccess('contribution', 'get', ['return' => 'soft_credit', 'sequential' => 1]);
1032
1033     $this->assertEquals($contact2['id'], $result['values'][0]['soft_credit'][1]['contact_id']);
1034     // Default soft credit amount = contribution.total_amount
1035     $this->assertEquals($this->_params['total_amount'], $result['values'][0]['soft_credit'][1]['amount']);
1036     $this->assertEquals(CRM_Core_OptionGroup::getDefaultValue("soft_credit_type"), $result['values'][0]['soft_credit'][1]['soft_credit_type']);
1037
1038     $this->callAPISuccess('contribution', 'delete', ['id' => $contribution['id']]);
1039     $this->callAPISuccess('contact', 'delete', ['id' => $contact2['id']]);
1040   }
1041
1042   /**
1043    * Test creating contribution with Soft Credit by passing in honor_contact_id.
1044    */
1045   public function testCreateContributionWithHonoreeContact() {
1046     $description = "Demonstrates creating contribution with Soft Credit by passing in honor_contact_id.";
1047     $subfile = "ContributionCreateWithHonoreeContact";
1048     $contact2 = $this->callAPISuccess('Contact', 'create', [
1049       'display_name' => 'superman',
1050       'contact_type' => 'Individual',
1051     ]);
1052     $params = $this->_params + [
1053       'honor_contact_id' => $contact2['id'],
1054     ];
1055     $contribution = $this->callAPIAndDocument('contribution', 'create', $params, __FUNCTION__, __FILE__, $description, $subfile);
1056     $result = $this->callAPISuccess('contribution', 'get', ['return' => 'soft_credit', 'sequential' => 1]);
1057
1058     $this->assertEquals($contact2['id'], $result['values'][0]['soft_credit'][1]['contact_id']);
1059     // Default soft credit amount = contribution.total_amount
1060     // Legacy mode in create api (honor_contact_id param) uses the standard "In Honor of" soft credit type
1061     $this->assertEquals($this->_params['total_amount'], $result['values'][0]['soft_credit'][1]['amount']);
1062     $softCreditValueTypeID = $result['values'][0]['soft_credit'][1]['soft_credit_type'];
1063     $this->assertEquals('in_honor_of', CRM_Core_PseudoConstant::getName('CRM_Contribute_BAO_ContributionSoft', 'soft_credit_type_id', $softCreditValueTypeID));
1064
1065     $this->callAPISuccess('contribution', 'delete', ['id' => $contribution['id']]);
1066     $this->callAPISuccess('contact', 'delete', ['id' => $contact2['id']]);
1067   }
1068
1069   /**
1070    * Test using example code.
1071    */
1072   public function testContributionCreateExample() {
1073     //make sure at least on page exists since there is a truncate in tear down
1074     $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1075     require_once 'api/v3/examples/Contribution/Create.ex.php';
1076     $result = contribution_create_example();
1077     $id = $result['id'];
1078     $expectedResult = contribution_create_expectedresult();
1079     $this->checkArrayEquals($expectedResult, $result);
1080     $this->contributionDelete($id);
1081   }
1082
1083   /**
1084    * Function tests that additional financial records are created when fee amount is recorded.
1085    */
1086   public function testCreateContributionWithFee() {
1087     $params = [
1088       'contact_id' => $this->_individualId,
1089       'receive_date' => '20120511',
1090       'total_amount' => 100.00,
1091       'fee_amount' => 50,
1092       'financial_type_id' => 1,
1093       'trxn_id' => 12345,
1094       'invoice_id' => 67890,
1095       'source' => 'SSF',
1096       'contribution_status_id' => 1,
1097     ];
1098
1099     $contribution = $this->callAPISuccess('contribution', 'create', $params);
1100     $this->assertEquals($contribution['values'][$contribution['id']]['contact_id'], $this->_individualId);
1101     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
1102     $this->assertEquals($contribution['values'][$contribution['id']]['fee_amount'], 50.00);
1103     $this->assertEquals($contribution['values'][$contribution['id']]['net_amount'], 50.00);
1104     $this->assertEquals($contribution['values'][$contribution['id']]['financial_type_id'], 1);
1105     $this->assertEquals($contribution['values'][$contribution['id']]['trxn_id'], 12345);
1106     $this->assertEquals($contribution['values'][$contribution['id']]['invoice_id'], 67890);
1107     $this->assertEquals($contribution['values'][$contribution['id']]['source'], 'SSF');
1108     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_status_id'], 1);
1109
1110     $lineItems = $this->callAPISuccess('line_item', 'get', [
1111
1112       'entity_id' => $contribution['id'],
1113       'entity_table' => 'civicrm_contribution',
1114       'sequential' => 1,
1115     ]);
1116     $this->assertEquals(1, $lineItems['count']);
1117     $this->assertEquals($contribution['id'], $lineItems['values'][0]['entity_id']);
1118     $this->assertEquals($contribution['id'], $lineItems['values'][0]['contribution_id']);
1119     $lineItems = $this->callAPISuccess('line_item', 'get', [
1120
1121       'entity_id' => $contribution['id'],
1122       'contribution_id' => $contribution['id'],
1123       'entity_table' => 'civicrm_contribution',
1124       'sequential' => 1,
1125     ]);
1126     $this->assertEquals(1, $lineItems['count']);
1127     $this->_checkFinancialRecords($contribution, 'feeAmount');
1128   }
1129
1130   /**
1131    * Function tests that additional financial records are created when online contribution is created.
1132    */
1133   public function testCreateContributionOnline() {
1134     CRM_Financial_BAO_PaymentProcessor::create($this->_processorParams);
1135     $contributionPage = $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1136     $this->assertAPISuccess($contributionPage);
1137     $params = [
1138       'contact_id' => $this->_individualId,
1139       'receive_date' => '20120511',
1140       'total_amount' => 100.00,
1141       'financial_type_id' => 1,
1142       'contribution_page_id' => $contributionPage['id'],
1143       'payment_processor' => $this->paymentProcessorID,
1144       'trxn_id' => 12345,
1145       'invoice_id' => 67890,
1146       'source' => 'SSF',
1147       'contribution_status_id' => 1,
1148
1149     ];
1150
1151     $contribution = $this->callAPISuccess('contribution', 'create', $params);
1152     $this->assertEquals($contribution['values'][$contribution['id']]['contact_id'], $this->_individualId);
1153     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
1154     $this->assertEquals($contribution['values'][$contribution['id']]['financial_type_id'], 1);
1155     $this->assertEquals($contribution['values'][$contribution['id']]['trxn_id'], 12345);
1156     $this->assertEquals($contribution['values'][$contribution['id']]['invoice_id'], 67890);
1157     $this->assertEquals($contribution['values'][$contribution['id']]['source'], 'SSF');
1158     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_status_id'], 1);
1159     $contribution['payment_instrument_id'] = $this->callAPISuccessGetValue('PaymentProcessor', [
1160       'id' => $this->paymentProcessorID,
1161       'return' => 'payment_instrument_id',
1162     ]);
1163     $this->_checkFinancialRecords($contribution, 'online');
1164   }
1165
1166   /**
1167    * Check handling of financial type.
1168    *
1169    * In the interests of removing financial type / contribution type checks from
1170    * legacy format function lets test that the api is doing this for us
1171    */
1172   public function testCreateInvalidFinancialType() {
1173     $params = $this->_params;
1174     $params['financial_type_id'] = 99999;
1175     $this->callAPIFailure($this->entity, 'create', $params, "'99999' is not a valid option for field financial_type_id");
1176   }
1177
1178   /**
1179    * Check handling of financial type.
1180    *
1181    * In the interests of removing financial type / contribution type checks from
1182    * legacy format function lets test that the api is doing this for us
1183    *
1184    * @throws \CRM_Core_Exception
1185    */
1186   public function testValidNamedFinancialType() {
1187     $params = $this->_params;
1188     $params['financial_type_id'] = 'Donation';
1189     $this->callAPISuccess($this->entity, 'create', $params);
1190   }
1191
1192   /**
1193    * Tests that additional financial records are created.
1194    *
1195    * Checks when online contribution with pay later option is created
1196    *
1197    * @throws \CRM_Core_Exception
1198    */
1199   public function testCreateContributionPayLaterOnline() {
1200     $this->_pageParams['is_pay_later'] = 1;
1201     $contributionPage = $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1202     $this->assertAPISuccess($contributionPage);
1203     $params = [
1204       'contact_id' => $this->_individualId,
1205       'receive_date' => '20120511',
1206       'total_amount' => 100.00,
1207       'financial_type_id' => 1,
1208       'contribution_page_id' => $contributionPage['id'],
1209       'trxn_id' => 12345,
1210       'is_pay_later' => 1,
1211       'invoice_id' => 67890,
1212       'source' => 'SSF',
1213       'contribution_status_id' => 'Pending',
1214
1215     ];
1216
1217     $contribution = $this->callAPIAndDocument('Contribution', 'create', $params, __FUNCTION__, __FILE__);
1218     $contribution = $contribution['values'][$contribution['id']];
1219     $this->assertEquals($contribution['contact_id'], $this->_individualId);
1220     $this->assertEquals($contribution['total_amount'], 100.00);
1221     $this->assertEquals($contribution['financial_type_id'], 1);
1222     $this->assertEquals($contribution['trxn_id'], 12345);
1223     $this->assertEquals($contribution['invoice_id'], 67890);
1224     $this->assertEquals($contribution['source'], 'SSF');
1225     $this->assertEquals($contribution['contribution_status_id'], 2);
1226     $this->_checkFinancialRecords($contribution, 'payLater');
1227   }
1228
1229   /**
1230    * Function tests that additional financial records are created for online contribution with pending option.
1231    */
1232   public function testCreateContributionPendingOnline() {
1233     CRM_Financial_BAO_PaymentProcessor::create($this->_processorParams);
1234     $contributionPage = $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1235     $this->assertAPISuccess($contributionPage);
1236     $params = [
1237       'contact_id' => $this->_individualId,
1238       'receive_date' => '20120511',
1239       'total_amount' => 100.00,
1240       'financial_type_id' => 1,
1241       'contribution_page_id' => $contributionPage['id'],
1242       'trxn_id' => 12345,
1243       'invoice_id' => 67890,
1244       'source' => 'SSF',
1245       'contribution_status_id' => 2,
1246     ];
1247
1248     $contribution = $this->callAPISuccess('contribution', 'create', $params);
1249     $this->assertEquals($contribution['values'][$contribution['id']]['contact_id'], $this->_individualId);
1250     $this->assertEquals($contribution['values'][$contribution['id']]['total_amount'], 100.00);
1251     $this->assertEquals($contribution['values'][$contribution['id']]['financial_type_id'], 1);
1252     $this->assertEquals($contribution['values'][$contribution['id']]['trxn_id'], 12345);
1253     $this->assertEquals($contribution['values'][$contribution['id']]['invoice_id'], 67890);
1254     $this->assertEquals($contribution['values'][$contribution['id']]['source'], 'SSF');
1255     $this->assertEquals($contribution['values'][$contribution['id']]['contribution_status_id'], 2);
1256     $this->_checkFinancialRecords($contribution, 'pending');
1257   }
1258
1259   /**
1260    * Test that BAO defaults work.
1261    *
1262    * @throws \CRM_Core_Exception
1263    */
1264   public function testCreateBAODefaults() {
1265     unset($this->_params['contribution_source_id'], $this->_params['payment_instrument_id']);
1266     $contribution = $this->callAPISuccess('Contribution', 'create', $this->_params);
1267     $contribution = $this->callAPISuccess('Contribution', 'getsingle', [
1268       'id' => $contribution['id'],
1269       'api.contribution.delete' => 1,
1270     ]);
1271     $this->assertEquals(1, $contribution['contribution_status_id']);
1272     $this->assertEquals('Check', $contribution['payment_instrument']);
1273     $this->callAPISuccessGetCount('Contribution', ['id' => $contribution['id']], 0);
1274   }
1275
1276   /**
1277    * Test that getsingle can be chained with delete.
1278    *
1279    * @throws CRM_Core_Exception
1280    */
1281   public function testDeleteChainedGetSingle() {
1282     $contribution = $this->callAPISuccess('Contribution', 'create', $this->_params);
1283     $contribution = $this->callAPISuccess('Contribution', 'getsingle', [
1284       'id' => $contribution['id'],
1285       'api.contribution.delete' => 1,
1286     ]);
1287     $this->callAPISuccessGetCount('Contribution', ['id' => $contribution['id']], 0);
1288   }
1289
1290   /**
1291    * Function tests that line items, financial records are updated when contribution amount is changed.
1292    *
1293    * @throws \CRM_Core_Exception
1294    */
1295   public function testCreateUpdateContributionChangeTotal() {
1296     $contribution = $this->callAPISuccess('contribution', 'create', $this->_params);
1297     $lineItems = $this->callAPISuccess('line_item', 'getvalue', [
1298
1299       'entity_id' => $contribution['id'],
1300       'entity_table' => 'civicrm_contribution',
1301       'sequential' => 1,
1302       'return' => 'line_total',
1303     ]);
1304     $this->assertEquals('100.00', $lineItems);
1305     $trxnAmount = $this->_getFinancialTrxnAmount($contribution['id']);
1306     // Financial trxn SUM = 100 + 5 (fee)
1307     $this->assertEquals('105.00', $trxnAmount);
1308     $newParams = [
1309
1310       'id' => $contribution['id'],
1311       'total_amount' => '125',
1312     ];
1313     $contribution = $this->callAPISuccess('Contribution', 'create', $newParams);
1314
1315     $lineItems = $this->callAPISuccess('line_item', 'getvalue', [
1316
1317       'entity_id' => $contribution['id'],
1318       'entity_table' => 'civicrm_contribution',
1319       'sequential' => 1,
1320       'return' => 'line_total',
1321     ]);
1322
1323     $this->assertEquals('125.00', $lineItems);
1324     $trxnAmount = $this->_getFinancialTrxnAmount($contribution['id']);
1325
1326     // Financial trxn SUM = 125 + 5 (fee).
1327     $this->assertEquals('130.00', $trxnAmount);
1328     $this->assertEquals('125.00', $this->_getFinancialItemAmount($contribution['id']));
1329   }
1330
1331   /**
1332    * Function tests that line items, financial records are updated when pay later contribution is received.
1333    */
1334   public function testCreateUpdateContributionPayLater() {
1335     $contribParams = [
1336       'contact_id' => $this->_individualId,
1337       'receive_date' => '2012-01-01',
1338       'total_amount' => 100.00,
1339       'financial_type_id' => $this->_financialTypeId,
1340       'payment_instrument_id' => 1,
1341       'contribution_status_id' => 2,
1342       'is_pay_later' => 1,
1343
1344     ];
1345     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1346
1347     $newParams = array_merge($contribParams, [
1348       'id' => $contribution['id'],
1349       'contribution_status_id' => 1,
1350     ]);
1351     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1352     $contribution = $contribution['values'][$contribution['id']];
1353     $this->assertEquals($contribution['contribution_status_id'], '1');
1354     $this->_checkFinancialItem($contribution['id'], 'paylater');
1355     $this->_checkFinancialTrxn($contribution, 'payLater');
1356   }
1357
1358   /**
1359    * Function tests that financial records are updated when Payment Instrument is changed.
1360    */
1361   public function testCreateUpdateContributionPaymentInstrument() {
1362     $instrumentId = $this->_addPaymentInstrument();
1363     $contribParams = [
1364       'contact_id' => $this->_individualId,
1365       'total_amount' => 100.00,
1366       'financial_type_id' => $this->_financialTypeId,
1367       'payment_instrument_id' => 4,
1368       'contribution_status_id' => 1,
1369
1370     ];
1371     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1372
1373     $newParams = array_merge($contribParams, [
1374       'id' => $contribution['id'],
1375       'payment_instrument_id' => $instrumentId,
1376     ]);
1377     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1378     $this->assertAPISuccess($contribution);
1379     $this->checkFinancialTrxnPaymentInstrumentChange($contribution['id'], 4, $instrumentId);
1380
1381     // cleanup - delete created payment instrument
1382     $this->_deletedAddedPaymentInstrument();
1383   }
1384
1385   /**
1386    * Function tests that financial records are updated when Payment Instrument is changed when amount is negative.
1387    */
1388   public function testCreateUpdateNegativeContributionPaymentInstrument() {
1389     $instrumentId = $this->_addPaymentInstrument();
1390     $contribParams = [
1391       'contact_id' => $this->_individualId,
1392       'total_amount' => -100.00,
1393       'financial_type_id' => $this->_financialTypeId,
1394       'payment_instrument_id' => 4,
1395       'contribution_status_id' => 1,
1396
1397     ];
1398     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1399
1400     $newParams = array_merge($contribParams, [
1401       'id' => $contribution['id'],
1402       'payment_instrument_id' => $instrumentId,
1403     ]);
1404     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1405     $this->assertAPISuccess($contribution);
1406     $this->checkFinancialTrxnPaymentInstrumentChange($contribution['id'], 4, $instrumentId, -100);
1407
1408     // cleanup - delete created payment instrument
1409     $this->_deletedAddedPaymentInstrument();
1410   }
1411
1412   /**
1413    * Function tests that financial records are added when Contribution is Refunded.
1414    *
1415    * @throws \CRM_Core_Exception
1416    */
1417   public function testCreateUpdateContributionRefund() {
1418     $contributionParams = [
1419       'contact_id' => $this->_individualId,
1420       'receive_date' => '2012-01-01',
1421       'total_amount' => 100.00,
1422       'financial_type_id' => $this->_financialTypeId,
1423       'payment_instrument_id' => 4,
1424       'contribution_status_id' => 1,
1425       'trxn_id' => 'original_payment',
1426     ];
1427     $contribution = $this->callAPISuccess('Contribution', 'create', $contributionParams);
1428     $newParams = array_merge($contributionParams, [
1429       'id' => $contribution['id'],
1430       'contribution_status_id' => 'Refunded',
1431       'cancel_date' => '2015-01-01 09:00',
1432       'refund_trxn_id' => 'the refund',
1433     ]);
1434
1435     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1436     $this->_checkFinancialTrxn($contribution, 'refund');
1437     $this->_checkFinancialItem($contribution['id'], 'refund');
1438     $this->assertEquals('original_payment', $this->callAPISuccessGetValue('Contribution', [
1439       'id' => $contribution['id'],
1440       'return' => 'trxn_id',
1441     ]));
1442   }
1443
1444   /**
1445    * Refund a contribution for a financial type with a contra account.
1446    *
1447    * CRM-17951 the contra account is a financial account with a relationship to a
1448    * financial type. It is not always configured but should be reflected
1449    * in the financial_trxn & financial_item table if it is.
1450    *
1451    * @throws \CRM_Core_Exception
1452    */
1453   public function testCreateUpdateChargebackContributionDefaultAccount() {
1454     $contribution = $this->callAPISuccess('Contribution', 'create', $this->_params);
1455     $this->callAPISuccess('Contribution', 'create', [
1456       'id' => $contribution['id'],
1457       'contribution_status_id' => 'Chargeback',
1458     ]);
1459     $this->callAPISuccessGetSingle('Contribution', ['contribution_status_id' => 'Chargeback']);
1460
1461     $lineItems = $this->callAPISuccessGetSingle('LineItem', [
1462       'contribution_id' => $contribution['id'],
1463       'api.FinancialItem.getsingle' => ['amount' => ['<' => 0]],
1464     ]);
1465     $this->assertEquals(1, $lineItems['api.FinancialItem.getsingle']['financial_account_id']);
1466     $this->callAPISuccessGetSingle('FinancialTrxn', [
1467       'total_amount' => -100,
1468       'status_id' => 'Chargeback',
1469       'to_financial_account_id' => 6,
1470     ]);
1471   }
1472
1473   /**
1474    * Refund a contribution for a financial type with a contra account.
1475    *
1476    * CRM-17951 the contra account is a financial account with a relationship to a
1477    * financial type. It is not always configured but should be reflected
1478    * in the financial_trxn & financial_item table if it is.
1479    *
1480    * @throws \CRM_Core_Exception
1481    */
1482   public function testCreateUpdateChargebackContributionCustomAccount() {
1483     $financialAccount = $this->callAPISuccess('FinancialAccount', 'create', [
1484       'name' => 'Chargeback Account',
1485       'is_active' => TRUE,
1486     ]);
1487
1488     $entityFinancialAccount = $this->callAPISuccess('EntityFinancialAccount', 'create', [
1489       'entity_id' => $this->_financialTypeId,
1490       'entity_table' => 'civicrm_financial_type',
1491       'account_relationship' => 'Chargeback Account is',
1492       'financial_account_id' => 'Chargeback Account',
1493     ]);
1494
1495     $contribution = $this->callAPISuccess('Contribution', 'create', $this->_params);
1496     $this->callAPISuccess('Contribution', 'create', [
1497       'id' => $contribution['id'],
1498       'contribution_status_id' => 'Chargeback',
1499     ]);
1500     $this->callAPISuccessGetSingle('Contribution', ['contribution_status_id' => 'Chargeback']);
1501
1502     $lineItems = $this->callAPISuccessGetSingle('LineItem', [
1503       'contribution_id' => $contribution['id'],
1504       'api.FinancialItem.getsingle' => ['amount' => ['<' => 0]],
1505     ]);
1506     $this->assertEquals($financialAccount['id'], $lineItems['api.FinancialItem.getsingle']['financial_account_id']);
1507
1508     $this->callAPISuccess('Contribution', 'delete', ['id' => $contribution['id']]);
1509     $this->callAPISuccess('EntityFinancialAccount', 'delete', ['id' => $entityFinancialAccount['id']]);
1510     $this->callAPISuccess('FinancialAccount', 'delete', ['id' => $financialAccount['id']]);
1511   }
1512
1513   /**
1514    * Refund a contribution for a financial type with a contra account.
1515    *
1516    * CRM-17951 the contra account is a financial account with a relationship to a
1517    * financial type. It is not always configured but should be reflected
1518    * in the financial_trxn & financial_item table if it is.
1519    */
1520   public function testCreateUpdateRefundContributionConfiguredContraAccount() {
1521     $financialAccount = $this->callAPISuccess('FinancialAccount', 'create', [
1522       'name' => 'Refund Account',
1523       'is_active' => TRUE,
1524     ]);
1525
1526     $entityFinancialAccount = $this->callAPISuccess('EntityFinancialAccount', 'create', [
1527       'entity_id' => $this->_financialTypeId,
1528       'entity_table' => 'civicrm_financial_type',
1529       'account_relationship' => 'Credit/Contra Revenue Account is',
1530       'financial_account_id' => 'Refund Account',
1531     ]);
1532
1533     $contribution = $this->callAPISuccess('Contribution', 'create', $this->_params);
1534     $this->callAPISuccess('Contribution', 'create', [
1535       'id' => $contribution['id'],
1536       'contribution_status_id' => 'Refunded',
1537     ]);
1538
1539     $lineItems = $this->callAPISuccessGetSingle('LineItem', [
1540       'contribution_id' => $contribution['id'],
1541       'api.FinancialItem.getsingle' => ['amount' => ['<' => 0]],
1542     ]);
1543     $this->assertEquals($financialAccount['id'], $lineItems['api.FinancialItem.getsingle']['financial_account_id']);
1544
1545     $this->callAPISuccess('Contribution', 'delete', ['id' => $contribution['id']]);
1546     $this->callAPISuccess('EntityFinancialAccount', 'delete', ['id' => $entityFinancialAccount['id']]);
1547     $this->callAPISuccess('FinancialAccount', 'delete', ['id' => $financialAccount['id']]);
1548   }
1549
1550   /**
1551    * Function tests that trxn_id is set when passed in.
1552    *
1553    * Here we ensure that the civicrm_financial_trxn.trxn_id & the civicrm_contribution.trxn_id are set
1554    * when trxn_id is passed in.
1555    */
1556   public function testCreateUpdateContributionRefundTrxnIDPassedIn() {
1557     $contributionParams = [
1558       'contact_id' => $this->_individualId,
1559       'receive_date' => '2012-01-01',
1560       'total_amount' => 100.00,
1561       'financial_type_id' => $this->_financialTypeId,
1562       'payment_instrument_id' => 4,
1563       'contribution_status_id' => 1,
1564       'trxn_id' => 'original_payment',
1565     ];
1566     $contribution = $this->callAPISuccess('contribution', 'create', $contributionParams);
1567     $newParams = array_merge($contributionParams, [
1568       'id' => $contribution['id'],
1569       'contribution_status_id' => 'Refunded',
1570       'cancel_date' => '2015-01-01 09:00',
1571       'trxn_id' => 'the refund',
1572     ]);
1573
1574     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1575     $this->_checkFinancialTrxn($contribution, 'refund');
1576     $this->_checkFinancialItem($contribution['id'], 'refund');
1577     $this->assertEquals('the refund', $this->callAPISuccessGetValue('Contribution', [
1578       'id' => $contribution['id'],
1579       'return' => 'trxn_id',
1580     ]));
1581   }
1582
1583   /**
1584    * Function tests that trxn_id is set when passed in.
1585    *
1586    * Here we ensure that the civicrm_contribution.trxn_id is set
1587    * when trxn_id is passed in but if refund_trxn_id is different then that
1588    * is kept for the refund transaction.
1589    */
1590   public function testCreateUpdateContributionRefundRefundAndTrxnIDPassedIn() {
1591     $contributionParams = [
1592       'contact_id' => $this->_individualId,
1593       'receive_date' => '2012-01-01',
1594       'total_amount' => 100.00,
1595       'financial_type_id' => $this->_financialTypeId,
1596       'payment_instrument_id' => 4,
1597       'contribution_status_id' => 1,
1598       'trxn_id' => 'original_payment',
1599     ];
1600     $contribution = $this->callAPISuccess('contribution', 'create', $contributionParams);
1601     $newParams = array_merge($contributionParams, [
1602       'id' => $contribution['id'],
1603       'contribution_status_id' => 'Refunded',
1604       'cancel_date' => '2015-01-01 09:00',
1605       'trxn_id' => 'cont id',
1606       'refund_trxn_id' => 'the refund',
1607     ]);
1608
1609     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1610     $this->_checkFinancialTrxn($contribution, 'refund');
1611     $this->_checkFinancialItem($contribution['id'], 'refund');
1612     $this->assertEquals('cont id', $this->callAPISuccessGetValue('Contribution', [
1613       'id' => $contribution['id'],
1614       'return' => 'trxn_id',
1615     ]));
1616   }
1617
1618   /**
1619    * Function tests that refund_trxn_id is set when passed in empty.
1620    *
1621    * Here we ensure that the civicrm_contribution.trxn_id is set
1622    * when trxn_id is passed in but if refund_trxn_id isset but empty then that
1623    * is kept for the refund transaction.
1624    */
1625   public function testCreateUpdateContributionRefundRefundNullTrxnIDPassedIn() {
1626     $contributionParams = [
1627       'contact_id' => $this->_individualId,
1628       'receive_date' => '2012-01-01',
1629       'total_amount' => 100.00,
1630       'financial_type_id' => $this->_financialTypeId,
1631       'payment_instrument_id' => 4,
1632       'contribution_status_id' => 1,
1633       'trxn_id' => 'original_payment',
1634     ];
1635     $contribution = $this->callAPISuccess('contribution', 'create', $contributionParams);
1636     $newParams = array_merge($contributionParams, [
1637       'id' => $contribution['id'],
1638       'contribution_status_id' => 'Refunded',
1639       'cancel_date' => '2015-01-01 09:00',
1640       'trxn_id' => 'cont id',
1641       'refund_trxn_id' => '',
1642     ]);
1643
1644     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1645     $this->_checkFinancialTrxn($contribution, 'refund', NULL, ['trxn_id' => NULL]);
1646     $this->_checkFinancialItem($contribution['id'], 'refund');
1647     $this->assertEquals('cont id', $this->callAPISuccessGetValue('Contribution', [
1648       'id' => $contribution['id'],
1649       'return' => 'trxn_id',
1650     ]));
1651   }
1652
1653   /**
1654    * Function tests invalid contribution status change.
1655    */
1656   public function testCreateUpdateContributionInValidStatusChange() {
1657     $contribParams = [
1658       'contact_id' => 1,
1659       'receive_date' => '2012-01-01',
1660       'total_amount' => 100.00,
1661       'financial_type_id' => 1,
1662       'payment_instrument_id' => 1,
1663       'contribution_status_id' => 1,
1664     ];
1665     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1666     $newParams = array_merge($contribParams, [
1667       'id' => $contribution['id'],
1668       'contribution_status_id' => 2,
1669     ]);
1670     $this->callAPIFailure('contribution', 'create', $newParams, ts('Cannot change contribution status from Completed to Pending.'));
1671
1672   }
1673
1674   /**
1675    * Function tests that financial records are added when Pending Contribution is Canceled.
1676    *
1677    * @throws \CRM_Core_Exception
1678    */
1679   public function testCreateUpdateContributionCancelPending() {
1680     $contribParams = [
1681       'contact_id' => $this->_individualId,
1682       'receive_date' => '2012-01-01',
1683       'total_amount' => 100.00,
1684       'financial_type_id' => $this->_financialTypeId,
1685       'payment_instrument_id' => 1,
1686       'contribution_status_id' => 2,
1687       'is_pay_later' => 1,
1688
1689     ];
1690     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1691     $newParams = array_merge($contribParams, [
1692       'id' => $contribution['id'],
1693       'contribution_status_id' => 3,
1694       'cancel_date' => '2012-02-02 09:00',
1695     ]);
1696     //Check if trxn_date is same as cancel_date.
1697     $checkTrxnDate = [
1698       'trxn_date' => '2012-02-02 09:00:00',
1699     ];
1700     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1701     $this->_checkFinancialTrxn($contribution, 'cancelPending', NULL, $checkTrxnDate);
1702     $this->_checkFinancialItem($contribution['id'], 'cancelPending');
1703   }
1704
1705   /**
1706    * Function tests that financial records are added when Financial Type is Changed.
1707    *
1708    * @throws \CRM_Core_Exception
1709    */
1710   public function testCreateUpdateContributionChangeFinancialType() {
1711     $contribParams = [
1712       'contact_id' => $this->_individualId,
1713       'receive_date' => '2012-01-01',
1714       'total_amount' => 100.00,
1715       'financial_type_id' => 1,
1716       'payment_instrument_id' => 1,
1717       'contribution_status_id' => 1,
1718
1719     ];
1720     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1721     $newParams = array_merge($contribParams, [
1722       'id' => $contribution['id'],
1723       'financial_type_id' => 3,
1724     ]);
1725     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1726     $this->_checkFinancialTrxn($contribution, 'changeFinancial');
1727     $this->_checkFinancialItem($contribution['id'], 'changeFinancial');
1728   }
1729
1730   /**
1731    * Function tets that financial records are correctly added when financial type is changed
1732    *
1733    * @throws \CRM_Core_Exception
1734    */
1735   public function testCreateUpdateContributionWithFeeAmountChangeFinancialType() {
1736     $contribParams = [
1737       'contact_id' => $this->_individualId,
1738       'receive_date' => '2012-01-01',
1739       'total_amount' => 100.00,
1740       'fee_amount' => 0.57,
1741       'financial_type_id' => 1,
1742       'payment_instrument_id' => 1,
1743       'contribution_status_id' => 1,
1744
1745     ];
1746     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
1747     $newParams = array_merge($contribParams, [
1748       'id' => $contribution['id'],
1749       'financial_type_id' => 3,
1750     ]);
1751     $contribution = $this->callAPISuccess('contribution', 'create', $newParams);
1752     $this->_checkFinancialTrxn($contribution, 'changeFinancial', NULL, ['fee_amount' => '-0.57', 'net_amount' => '-99.43']);
1753     $this->_checkFinancialItem($contribution['id'], 'changeFinancial');
1754   }
1755
1756   /**
1757    * Test that update does not change status id CRM-15105.
1758    */
1759   public function testCreateUpdateWithoutChangingPendingStatus() {
1760     $contribution = $this->callAPISuccess('contribution', 'create', array_merge($this->_params, ['contribution_status_id' => 2]));
1761     $this->callAPISuccess('contribution', 'create', ['id' => $contribution['id'], 'source' => 'new source']);
1762     $contribution = $this->callAPISuccess('contribution', 'getsingle', [
1763       'id' => $contribution['id'],
1764       'api.contribution.delete' => 1,
1765     ]);
1766     $this->assertEquals(2, $contribution['contribution_status_id']);
1767   }
1768
1769   /**
1770    * Test Updating a Contribution.
1771    *
1772    * CHANGE: we require the API to do an incremental update
1773    */
1774   public function testCreateUpdateContribution() {
1775     $contributionID = $this->contributionCreate([
1776       'contact_id' => $this->_individualId,
1777       'trxn_id' => 212355,
1778       'financial_type_id' => $this->_financialTypeId,
1779       'invoice_id' => 'old_invoice',
1780     ]);
1781     $old_params = [
1782       'contribution_id' => $contributionID,
1783     ];
1784     $original = $this->callAPISuccess('contribution', 'get', $old_params);
1785     $this->assertEquals($original['id'], $contributionID);
1786     //set up list of old params, verify
1787
1788     //This should not be required on update:
1789     $old_contact_id = $original['values'][$contributionID]['contact_id'];
1790     $old_payment_instrument = $original['values'][$contributionID]['instrument_id'];
1791     $old_fee_amount = $original['values'][$contributionID]['fee_amount'];
1792     $old_source = $original['values'][$contributionID]['contribution_source'];
1793
1794     $old_trxn_id = $original['values'][$contributionID]['trxn_id'];
1795     $old_invoice_id = $original['values'][$contributionID]['invoice_id'];
1796
1797     //check against values in CiviUnitTestCase::createContribution()
1798     $this->assertEquals($old_contact_id, $this->_individualId);
1799     $this->assertEquals($old_fee_amount, 5.00);
1800     $this->assertEquals($old_source, 'SSF');
1801     $this->assertEquals($old_trxn_id, 212355);
1802     $this->assertEquals($old_invoice_id, 'old_invoice');
1803     $params = [
1804       'id' => $contributionID,
1805       'contact_id' => $this->_individualId,
1806       'total_amount' => 105.00,
1807       'fee_amount' => 7.00,
1808       'financial_type_id' => $this->_financialTypeId,
1809       'non_deductible_amount' => 22.00,
1810       'contribution_status_id' => 1,
1811       'note' => 'Donating for Noble Cause',
1812     ];
1813
1814     $contribution = $this->callAPISuccess('contribution', 'create', $params);
1815
1816     $new_params = [
1817       'contribution_id' => $contribution['id'],
1818     ];
1819     $contribution = $this->callAPISuccessGetSingle('contribution', $new_params);
1820
1821     $this->assertEquals($contribution['contact_id'], $this->_individualId);
1822     $this->assertEquals($contribution['total_amount'], 105.00);
1823     $this->assertEquals($contribution['financial_type_id'], $this->_financialTypeId);
1824     $this->assertEquals($contribution['financial_type'], 'Donation');
1825     $this->assertEquals($contribution['instrument_id'], $old_payment_instrument);
1826     $this->assertEquals($contribution['non_deductible_amount'], 22.00);
1827     $this->assertEquals($contribution['fee_amount'], 7.00);
1828     $this->assertEquals($contribution['trxn_id'], $old_trxn_id);
1829     $this->assertEquals($contribution['invoice_id'], $old_invoice_id);
1830     $this->assertEquals($contribution['contribution_source'], $old_source);
1831     $this->assertEquals($contribution['contribution_status'], 'Completed');
1832
1833     $this->assertEquals($contribution['net_amount'], $contribution['total_amount'] - $contribution['fee_amount']);
1834
1835     $params = [
1836       'contribution_id' => $contributionID,
1837     ];
1838     $result = $this->callAPISuccess('contribution', 'delete', $params);
1839     $this->assertAPISuccess($result);
1840   }
1841
1842   /**
1843    * Check that net_amount is updated when a contribution is updated.
1844    *
1845    * Update fee amount AND total amount, just fee amount, just total amount
1846    * and neither to check that net_amount is keep updated.
1847    */
1848   public function testUpdateContributionNetAmountVariants() {
1849     $contributionID = $this->contributionCreate(['contact_id' => $this->individualCreate()]);
1850
1851     $this->callAPISuccess('Contribution', 'create', [
1852       'id' => $contributionID,
1853       'total_amount' => 90,
1854       'fee_amount' => 6,
1855     ]);
1856     $contribution = $this->callAPISuccessGetSingle('Contribution', [
1857       'id' => $contributionID,
1858       'return' => ['net_amount', 'fee_amount', 'total_amount'],
1859     ]);
1860     $this->assertEquals(6, $contribution['fee_amount']);
1861     $this->assertEquals(90, $contribution['total_amount']);
1862     $this->assertEquals(84, $contribution['net_amount']);
1863
1864     $this->callAPISuccess('Contribution', 'create', [
1865       'id' => $contributionID,
1866       'fee_amount' => 3,
1867     ]);
1868     $contribution = $this->callAPISuccessGetSingle('Contribution', [
1869       'id' => $contributionID,
1870       'return' => ['net_amount', 'fee_amount', 'total_amount'],
1871     ]);
1872     $this->assertEquals(3, $contribution['fee_amount']);
1873     $this->assertEquals(90, $contribution['total_amount']);
1874     $this->assertEquals(87, $contribution['net_amount']);
1875
1876     $this->callAPISuccess('Contribution', 'create', [
1877       'id' => $contributionID,
1878       'total_amount' => 200,
1879     ]);
1880     $contribution = $this->callAPISuccessGetSingle('Contribution', [
1881       'id' => $contributionID,
1882       'return' => ['net_amount', 'fee_amount', 'total_amount'],
1883     ]);
1884     $this->assertEquals(3, $contribution['fee_amount']);
1885     $this->assertEquals(200, $contribution['total_amount']);
1886     $this->assertEquals(197, $contribution['net_amount']);
1887
1888     $this->callAPISuccess('Contribution', 'create', [
1889       'id' => $contributionID,
1890       'payment_instrument' => 'Cash',
1891     ]);
1892     $contribution = $this->callAPISuccessGetSingle('Contribution', [
1893       'id' => $contributionID,
1894       'return' => ['net_amount', 'fee_amount', 'total_amount'],
1895     ]);
1896     $this->assertEquals(3, $contribution['fee_amount']);
1897     $this->assertEquals(200, $contribution['total_amount']);
1898     $this->assertEquals(197, $contribution['net_amount']);
1899   }
1900
1901   /**
1902    * Attempt (but fail) to delete a contribution without parameters.
1903    */
1904   public function testDeleteEmptyParamsContribution() {
1905     $params = [];
1906     $this->callAPIFailure('contribution', 'delete', $params);
1907   }
1908
1909   public function testDeleteParamsNotArrayContribution() {
1910     $this->expectException(TypeError::class);
1911     $params = 'contribution_id= 1';
1912     $contribution = $this->callAPIFailure('contribution', 'delete', $params);
1913   }
1914
1915   public function testDeleteWrongParamContribution() {
1916     $params = [
1917       'contribution_source' => 'SSF',
1918     ];
1919     $this->callAPIFailure('contribution', 'delete', $params);
1920   }
1921
1922   public function testDeleteContribution() {
1923     $contributionID = $this->contributionCreate([
1924       'contact_id' => $this->_individualId,
1925       'financial_type_id' => $this->_financialTypeId,
1926     ]);
1927     $params = [
1928       'id' => $contributionID,
1929     ];
1930     $this->callAPIAndDocument('contribution', 'delete', $params, __FUNCTION__, __FILE__);
1931   }
1932
1933   /**
1934    * Test civicrm_contribution_search with empty params.
1935    *
1936    * All available contributions expected.
1937    */
1938   public function testSearchEmptyParams() {
1939     $params = [];
1940
1941     $p = [
1942       'contact_id' => $this->_individualId,
1943       'receive_date' => date('Ymd'),
1944       'total_amount' => 100.00,
1945       'financial_type_id' => $this->_financialTypeId,
1946       'non_deductible_amount' => 10.00,
1947       'fee_amount' => 5.00,
1948       'net_amount' => 95.00,
1949       'trxn_id' => 23456,
1950       'invoice_id' => 78910,
1951       'source' => 'SSF',
1952       'contribution_status_id' => 1,
1953     ];
1954     $contribution = $this->callAPISuccess('contribution', 'create', $p);
1955
1956     $result = $this->callAPISuccess('contribution', 'get', $params);
1957     // We're taking the first element.
1958     $res = $result['values'][$contribution['id']];
1959
1960     $this->assertEquals($p['contact_id'], $res['contact_id']);
1961     $this->assertEquals($p['total_amount'], $res['total_amount']);
1962     $this->assertEquals($p['financial_type_id'], $res['financial_type_id']);
1963     $this->assertEquals($p['net_amount'], $res['net_amount']);
1964     $this->assertEquals($p['non_deductible_amount'], $res['non_deductible_amount']);
1965     $this->assertEquals($p['fee_amount'], $res['fee_amount']);
1966     $this->assertEquals($p['trxn_id'], $res['trxn_id']);
1967     $this->assertEquals($p['invoice_id'], $res['invoice_id']);
1968     $this->assertEquals($p['source'], $res['contribution_source']);
1969     // contribution_status_id = 1 => Completed
1970     $this->assertEquals('Completed', $res['contribution_status']);
1971
1972     $this->contributionDelete($contribution['id']);
1973   }
1974
1975   /**
1976    * Test civicrm_contribution_search. Success expected.
1977    */
1978   public function testSearch() {
1979     $p1 = [
1980       'contact_id' => $this->_individualId,
1981       'receive_date' => date('Ymd'),
1982       'total_amount' => 100.00,
1983       'financial_type_id' => $this->_financialTypeId,
1984       'non_deductible_amount' => 10.00,
1985       'contribution_status_id' => 1,
1986     ];
1987     $contribution1 = $this->callAPISuccess('contribution', 'create', $p1);
1988
1989     $p2 = [
1990       'contact_id' => $this->_individualId,
1991       'receive_date' => date('Ymd'),
1992       'total_amount' => 200.00,
1993       'financial_type_id' => $this->_financialTypeId,
1994       'non_deductible_amount' => 20.00,
1995       'trxn_id' => 5454565,
1996       'invoice_id' => 1212124,
1997       'fee_amount' => 50.00,
1998       'net_amount' => 60.00,
1999       'contribution_status_id' => 2,
2000     ];
2001     $contribution2 = $this->callAPISuccess('contribution', 'create', $p2);
2002
2003     $params = [
2004       'contribution_id' => $contribution2['id'],
2005     ];
2006     $result = $this->callAPISuccess('contribution', 'get', $params);
2007     $res = $result['values'][$contribution2['id']];
2008
2009     $this->assertEquals($p2['contact_id'], $res['contact_id']);
2010     $this->assertEquals($p2['total_amount'], $res['total_amount']);
2011     $this->assertEquals($p2['financial_type_id'], $res['financial_type_id']);
2012     $this->assertEquals($p2['net_amount'], $res['net_amount']);
2013     $this->assertEquals($p2['non_deductible_amount'], $res['non_deductible_amount']);
2014     $this->assertEquals($p2['fee_amount'], $res['fee_amount']);
2015     $this->assertEquals($p2['trxn_id'], $res['trxn_id']);
2016     $this->assertEquals($p2['invoice_id'], $res['invoice_id']);
2017     $this->assertEquals(CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Pending'), $res['contribution_status_id']);
2018
2019     $this->contributionDelete($contribution1['id']);
2020     $this->contributionDelete($contribution2['id']);
2021   }
2022
2023   /**
2024    * Test completing a transaction via the API.
2025    *
2026    * Note that we are creating a logged in user because email goes out from
2027    * that person
2028    */
2029   public function testCompleteTransaction() {
2030     $mut = new CiviMailUtils($this, TRUE);
2031     $this->swapMessageTemplateForTestTemplate();
2032     $this->createLoggedInUser();
2033     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
2034     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2035     $this->callAPISuccess('contribution', 'completetransaction', [
2036       'id' => $contribution['id'],
2037     ]);
2038     $contribution = $this->callAPISuccess('contribution', 'getsingle', ['id' => $contribution['id']]);
2039     $this->assertEquals('SSF', $contribution['contribution_source']);
2040     $this->assertEquals('Completed', $contribution['contribution_status']);
2041     $this->assertEquals(date('Y-m-d'), date('Y-m-d', strtotime($contribution['receipt_date'])));
2042     $mut->checkMailLog([
2043       'email:::anthony_anderson@civicrm.org',
2044       'is_monetary:::1',
2045       'amount:::100.00',
2046       'currency:::USD',
2047       'receive_date:::' . date('Ymd', strtotime($contribution['receive_date'])),
2048       "receipt_date:::\n",
2049       'contributeMode:::notify',
2050       'title:::Contribution',
2051       'displayName:::Mr. Anthony Anderson II',
2052       'contributionStatus:::Completed',
2053     ]);
2054     $mut->stop();
2055     $this->revertTemplateToReservedTemplate();
2056   }
2057
2058   /**
2059    * Test completing a transaction via the API with a non-USD transaction.
2060    */
2061   public function testCompleteTransactionEuro() {
2062     $mut = new CiviMailUtils($this, TRUE);
2063     $this->swapMessageTemplateForTestTemplate();
2064     $this->createLoggedInUser();
2065     $params = array_merge($this->_params, ['contribution_status_id' => 2, 'currency' => 'EUR']);
2066     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2067
2068     $this->callAPISuccess('contribution', 'completetransaction', [
2069       'id' => $contribution['id'],
2070     ]);
2071
2072     $contribution = $this->callAPISuccess('contribution', 'getsingle', ['id' => $contribution['id']]);
2073     $this->assertEquals('SSF', $contribution['contribution_source']);
2074     $this->assertEquals('Completed', $contribution['contribution_status']);
2075     $this->assertEquals(date('Y-m-d'), date('Y-m-d', strtotime($contribution['receipt_date'])));
2076
2077     $entityFinancialTransactions = $this->getFinancialTransactionsForContribution($contribution['id']);
2078     $entityFinancialTransaction = reset($entityFinancialTransactions);
2079     $financialTrxn = $this->callAPISuccessGetSingle('FinancialTrxn', ['id' => $entityFinancialTransaction['financial_trxn_id']]);
2080     $this->assertEquals('EUR', $financialTrxn['currency']);
2081
2082     $mut->checkMailLog([
2083       'email:::anthony_anderson@civicrm.org',
2084       'is_monetary:::1',
2085       'amount:::100.00',
2086       'currency:::EUR',
2087       'receive_date:::' . date('Ymd', strtotime($contribution['receive_date'])),
2088       "receipt_date:::\n",
2089       'contributeMode:::notify',
2090       'title:::Contribution',
2091       'displayName:::Mr. Anthony Anderson II',
2092       'contributionStatus:::Completed',
2093     ]);
2094     $mut->stop();
2095     $this->revertTemplateToReservedTemplate();
2096   }
2097
2098   /**
2099    * Test to ensure mail is sent on chosing pay later
2100    */
2101   public function testpayLater() {
2102     $mut = new CiviMailUtils($this, TRUE);
2103     $this->swapMessageTemplateForTestTemplate();
2104     $this->createLoggedInUser();
2105
2106     // create contribution page first
2107     $contributionPageParams = [
2108       'title' => 'Help Support CiviCRM!',
2109       'financial_type_id' => 1,
2110       'is_monetary' => TRUE,
2111       'is_pay_later' => 1,
2112       'is_quick_config' => TRUE,
2113       'pay_later_text' => 'I will send payment by check',
2114       'pay_later_receipt' => 'This is a pay later reciept',
2115       'is_allow_other_amount' => 1,
2116       'min_amount' => 10.00,
2117       'max_amount' => 10000.00,
2118       'goal_amount' => 100000.00,
2119       'is_email_receipt' => 1,
2120       'is_active' => 1,
2121       'amount_block_is_active' => 1,
2122       'currency' => 'USD',
2123       'is_billing_required' => 0,
2124     ];
2125     $contributionPageResult = $this->callAPISuccess('contribution_page', 'create', $contributionPageParams);
2126
2127     // submit form values
2128     $priceSet = $this->callAPISuccess('price_set', 'getsingle', ['name' => 'default_contribution_amount']);
2129     $params = [
2130       'id' => $contributionPageResult['id'],
2131       'contact_id' => $this->_individualId,
2132       'email-5' => 'anthony_anderson@civicrm.org',
2133       'payment_processor_id' => 0,
2134       'amount' => 100.00,
2135       'tax_amount' => '',
2136       'currencyID' => 'USD',
2137       'is_pay_later' => 1,
2138       'invoiceID' => 'f28e1ddc86f8c4a0ff5bcf46393e4bc8',
2139       'is_quick_config' => 1,
2140       'description' => 'Online Contribution: Help Support CiviCRM!',
2141       'price_set_id' => $priceSet['id'],
2142     ];
2143     $this->callAPISuccess('contribution_page', 'submit', $params);
2144
2145     $mut->checkMailLog([
2146       'is_pay_later:::1',
2147       'email:::anthony_anderson@civicrm.org',
2148       'pay_later_receipt:::' . $contributionPageParams['pay_later_receipt'],
2149       'displayName:::Mr. Anthony Anderson II',
2150       'contributionPageId:::' . $contributionPageResult['id'],
2151       'title:::' . $contributionPageParams['title'],
2152       'amount:::' . $params['amount'],
2153     ]);
2154     $mut->stop();
2155     $this->revertTemplateToReservedTemplate();
2156   }
2157
2158   /**
2159    * Test to check whether contact billing address is used when no contribution address
2160    */
2161   public function testBillingAddress() {
2162     $mut = new CiviMailUtils($this, TRUE);
2163     $this->swapMessageTemplateForTestTemplate();
2164     $this->createLoggedInUser();
2165
2166     //Scenario 1: When Contact don't have any address
2167     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
2168     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2169     $this->callAPISuccess('contribution', 'completetransaction', [
2170       'id' => $contribution['id'],
2171     ]);
2172     $mut->checkMailLog([
2173       'address:::',
2174     ]);
2175
2176     // Scenario 2: Contribution using address
2177     $address = $this->callAPISuccess('address', 'create', [
2178       'street_address' => 'contribution billing st',
2179       'location_type_id' => 2,
2180       'contact_id' => $this->_params['contact_id'],
2181     ]);
2182     $params = array_merge($this->_params, [
2183       'contribution_status_id' => 2,
2184       'address_id' => $address['id'],
2185     ]
2186     );
2187     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2188     $this->callAPISuccess('contribution', 'completetransaction', [
2189       'id' => $contribution['id'],
2190     ]);
2191     $mut->checkMailLog([
2192       'address:::contribution billing st',
2193     ]);
2194
2195     // Scenario 3: Contribution wtth no address but contact has a billing address
2196     $this->callAPISuccess('address', 'create', [
2197       'id' => $address['id'],
2198       'street_address' => 'is billing st',
2199       'contact_id' => $this->_params['contact_id'],
2200     ]);
2201     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
2202     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2203     $this->callAPISuccess('contribution', 'completetransaction', [
2204       'id' => $contribution['id'],
2205     ]);
2206     $mut->checkMailLog([
2207       'address:::is billing st',
2208     ]);
2209
2210     $mut->stop();
2211     $this->revertTemplateToReservedTemplate();
2212   }
2213
2214   /**
2215    * Test completing a transaction via the API.
2216    *
2217    * Note that we are creating a logged in user because email goes out from
2218    * that person
2219    */
2220   public function testCompleteTransactionFeeAmount() {
2221     $this->createLoggedInUser();
2222     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
2223     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2224     $this->callAPISuccess('contribution', 'completetransaction', [
2225       'id' => $contribution['id'],
2226       'fee_amount' => '.56',
2227       'trxn_id' => '7778888',
2228     ]);
2229     $contribution = $this->callAPISuccess('contribution', 'getsingle', ['id' => $contribution['id'], 'sequential' => 1]);
2230     $this->assertEquals('Completed', $contribution['contribution_status']);
2231     $this->assertEquals('7778888', $contribution['trxn_id']);
2232     $this->assertEquals('0.56', $contribution['fee_amount']);
2233     $this->assertEquals('99.44', $contribution['net_amount']);
2234   }
2235
2236   /**
2237    * CRM-19126 Add test to verify when complete transaction is called tax amount is not changed.
2238    *
2239    * @param string $thousandSeparator
2240    *   punctuation used to refer to thousands.
2241    *
2242    * @dataProvider getThousandSeparators
2243    */
2244   public function testCheckTaxAmount($thousandSeparator) {
2245     $this->setCurrencySeparators($thousandSeparator);
2246     $contact = $this->createLoggedInUser();
2247     $financialType = $this->callAPISuccess('financial_type', 'create', [
2248       'name' => 'Test taxable financial Type',
2249       'is_reserved' => 0,
2250       'is_active' => 1,
2251     ]);
2252     $financialAccount = $this->callAPISuccess('financial_account', 'create', [
2253       'name' => 'Test Tax financial account ',
2254       'contact_id' => $contact,
2255       'financial_account_type_id' => 2,
2256       'is_tax' => 1,
2257       'tax_rate' => 5.00,
2258       'is_reserved' => 0,
2259       'is_active' => 1,
2260       'is_default' => 0,
2261     ]);
2262     $financialTypeId = $financialType['id'];
2263     $financialAccountId = $financialAccount['id'];
2264     $financialAccountParams = [
2265       'entity_table' => 'civicrm_financial_type',
2266       'entity_id' => $financialTypeId,
2267       'account_relationship' => 10,
2268       'financial_account_id' => $financialAccountId,
2269     ];
2270     CRM_Financial_BAO_FinancialTypeAccount::add($financialAccountParams);
2271
2272     $params = array_merge($this->_params, ['contribution_status_id' => 2, 'financial_type_id' => $financialTypeId]);
2273     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2274     $contribution1 = $this->callAPISuccess('contribution', 'get', ['id' => $contribution['id'], 'return' => 'tax_amount', 'sequential' => 1]);
2275     $this->callAPISuccess('contribution', 'completetransaction', [
2276       'id' => $contribution['id'],
2277       'trxn_id' => '777788888',
2278       'fee_amount' => '6.00',
2279     ]);
2280     $contribution2 = $this->callAPISuccess('contribution', 'get', ['id' => $contribution['id'], 'return' => ['tax_amount', 'fee_amount', 'net_amount'], 'sequential' => 1]);
2281     $this->assertEquals($contribution1['values'][0]['tax_amount'], $contribution2['values'][0]['tax_amount']);
2282     $this->assertEquals('6.00', $contribution2['values'][0]['fee_amount']);
2283     $this->assertEquals('99.00', $contribution2['values'][0]['net_amount']);
2284   }
2285
2286   /**
2287    * Test repeat contribution successfully creates line item.
2288    *
2289    * @throws \CRM_Core_Exception
2290    */
2291   public function testRepeatTransaction() {
2292     $originalContribution = $this->setUpRepeatTransaction($recurParams = [], 'single');
2293     $this->callAPISuccess('contribution', 'repeattransaction', [
2294       'original_contribution_id' => $originalContribution['id'],
2295       'contribution_status_id' => 'Completed',
2296       'trxn_id' => uniqid(),
2297     ]);
2298     $lineItemParams = [
2299       'entity_id' => $originalContribution['id'],
2300       'sequential' => 1,
2301       'return' => [
2302         'entity_table',
2303         'qty',
2304         'unit_price',
2305         'line_total',
2306         'label',
2307         'financial_type_id',
2308         'deductible_amount',
2309         'price_field_value_id',
2310         'price_field_id',
2311       ],
2312     ];
2313     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2314       'entity_id' => $originalContribution['id'],
2315     ]));
2316     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2317       'entity_id' => $originalContribution['id'] + 1,
2318     ]));
2319     unset($lineItem1['values'][0]['id'], $lineItem1['values'][0]['entity_id']);
2320     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2321     $this->assertEquals($lineItem1['values'][0], $lineItem2['values'][0]);
2322     $this->_checkFinancialRecords([
2323       'id' => $originalContribution['id'] + 1,
2324       'payment_instrument_id' => $this->callAPISuccessGetValue('PaymentProcessor', [
2325         'id' => $originalContribution['payment_processor_id'],
2326         'return' => 'payment_instrument_id',
2327       ]),
2328     ], 'online');
2329   }
2330
2331   /**
2332    * Test custom data is copied over from the template transaction.
2333    *
2334    * (Over time various discussions have deemed this to be the most recent one, allowing
2335    * users to alter custom data going forwards. This is implemented for line items already.
2336    *
2337    * @throws \API_Exception
2338    * @throws \CRM_Core_Exception
2339    */
2340   public function testRepeatTransactionWithCustomData() {
2341     $this->createCustomGroupWithFieldOfType(['extends' => 'Contribution', 'name' => 'Repeat'], 'text');
2342     $originalContribution = $this->setUpRepeatTransaction([], 'single', [$this->getCustomFieldName('text') => 'first']);
2343     $this->callAPISuccess('contribution', 'repeattransaction', [
2344       'contribution_recur_id' => $originalContribution['contribution_recur_id'],
2345       'contribution_status_id' => 'Completed',
2346       'trxn_id' => 'my_trxn',
2347     ]);
2348
2349     $contribution = Contribution::get()
2350       ->addWhere('trxn_id', '=', 'my_trxn')
2351       ->addSelect('Custom_Group.Enter_text_here')
2352       ->addSelect('id')
2353       ->execute()->first();
2354     $this->assertEquals('first', $contribution['Custom_Group.Enter_text_here']);
2355
2356     Contribution::update()->setValues(['Custom_Group.Enter_text_here' => 'second'])->addWhere('id', '=', $contribution['id'])->execute();
2357
2358     $this->callAPISuccess('contribution', 'repeattransaction', [
2359       'original_contribution_id' => $originalContribution['id'],
2360       'contribution_status_id' => 'Completed',
2361       'trxn_id' => 'number_3',
2362     ]);
2363
2364     $contribution = Contribution::get()
2365       ->addWhere('trxn_id', '=', 'number_3')
2366       ->setSelect(['id', 'Custom_Group.Enter_text_here'])
2367       ->execute()->first();
2368     $this->assertEquals('second', $contribution['Custom_Group.Enter_text_here']);
2369   }
2370
2371   /**
2372    * Test repeat contribution successfully creates line items (plural).
2373    *
2374    * @throws \CRM_Core_Exception
2375    */
2376   public function testRepeatTransactionLineItems() {
2377     // CRM-19309
2378     $originalContribution = $this->setUpRepeatTransaction($recurParams = [], 'multiple');
2379     $this->callAPISuccess('contribution', 'repeattransaction', [
2380       'original_contribution_id' => $originalContribution['id'],
2381       'contribution_status_id' => 'Completed',
2382       'trxn_id' => uniqid(),
2383     ]);
2384
2385     $lineItemParams = [
2386       'entity_id' => $originalContribution['id'],
2387       'sequential' => 1,
2388       'return' => [
2389         'entity_table',
2390         'qty',
2391         'unit_price',
2392         'line_total',
2393         'label',
2394         'financial_type_id',
2395         'deductible_amount',
2396         'price_field_value_id',
2397         'price_field_id',
2398       ],
2399     ];
2400     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2401       'entity_id' => $originalContribution['id'],
2402     ]));
2403     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2404       'entity_id' => $originalContribution['id'] + 1,
2405     ]));
2406
2407     // unset id and entity_id for all of them to be able to compare the lineItems:
2408     unset($lineItem1['values'][0]['id'], $lineItem1['values'][0]['entity_id']);
2409     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2410     $this->assertEquals($lineItem1['values'][0], $lineItem2['values'][0]);
2411
2412     unset($lineItem1['values'][1]['id'], $lineItem1['values'][1]['entity_id']);
2413     unset($lineItem2['values'][1]['id'], $lineItem2['values'][1]['entity_id']);
2414     $this->assertEquals($lineItem1['values'][1], $lineItem2['values'][1]);
2415
2416     // CRM-19309 so in future we also want to:
2417     // check that financial_line_items have been created for entity_id 3 and 4;
2418
2419     $this->callAPISuccessGetCount('FinancialItem', ['description' => 'Sales Tax', 'amount' => 0], 0);
2420   }
2421
2422   /**
2423    * Test repeat contribution successfully creates is_test transaction.
2424    */
2425   public function testRepeatTransactionIsTest() {
2426     $this->_params['is_test'] = 1;
2427     $originalContribution = $this->setUpRepeatTransaction(['is_test' => 1], 'single');
2428
2429     $this->callAPISuccess('contribution', 'repeattransaction', [
2430       'original_contribution_id' => $originalContribution['id'],
2431       'contribution_status_id' => 'Completed',
2432       'trxn_id' => uniqid(),
2433     ]);
2434     $this->callAPISuccessGetCount('Contribution', ['contribution_test' => 1], 2);
2435   }
2436
2437   /**
2438    * Test repeat contribution passed in status.
2439    */
2440   public function testRepeatTransactionPassedInStatus() {
2441     $originalContribution = $this->setUpRepeatTransaction($recurParams = [], 'single');
2442
2443     $this->callAPISuccess('contribution', 'repeattransaction', [
2444       'original_contribution_id' => $originalContribution['id'],
2445       'contribution_status_id' => 'Pending',
2446       'trxn_id' => uniqid(),
2447     ]);
2448     $this->callAPISuccessGetCount('Contribution', ['contribution_status_id' => 2], 1);
2449   }
2450
2451   /**
2452    * Test repeat contribution accepts recur_id instead of original_contribution_id.
2453    */
2454   public function testRepeatTransactionAcceptRecurID() {
2455     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', [
2456       'contact_id' => $this->_individualId,
2457       'installments' => '12',
2458       'frequency_interval' => '1',
2459       'amount' => '100',
2460       'contribution_status_id' => 1,
2461       'start_date' => '2012-01-01 00:00:00',
2462       'currency' => 'USD',
2463       'frequency_unit' => 'month',
2464       'payment_processor_id' => $this->paymentProcessorID,
2465     ]);
2466     $this->callAPISuccess('contribution', 'create', array_merge(
2467         $this->_params,
2468         ['contribution_recur_id' => $contributionRecur['id']])
2469     );
2470
2471     $this->callAPISuccess('contribution', 'repeattransaction', [
2472       'contribution_recur_id' => $contributionRecur['id'],
2473       'contribution_status_id' => 'Completed',
2474       'trxn_id' => uniqid(),
2475     ]);
2476
2477   }
2478
2479   /**
2480    * CRM-19873 Test repeattransaction if contribution_recur_id is a test.
2481    *
2482    * @throws \CRM_Core_Exception
2483    */
2484   public function testRepeatTransactionTestRecurId() {
2485     $contributionRecur = $this->callAPISuccess('ContributionRecur', 'create', [
2486       'contact_id' => $this->_individualId,
2487       'frequency_interval' => '1',
2488       'amount' => '1.00',
2489       'contribution_status_id' => 1,
2490       'start_date' => '2017-01-01 00:00:00',
2491       'currency' => 'USD',
2492       'frequency_unit' => 'month',
2493       'payment_processor_id' => $this->paymentProcessorID,
2494       'is_test' => 1,
2495     ]);
2496     $this->callAPISuccess('contribution', 'create', array_merge(
2497         $this->_params,
2498         [
2499           'contribution_recur_id' => $contributionRecur['id'],
2500           'is_test' => 1,
2501         ])
2502     );
2503
2504     $repeatedContribution = $this->callAPISuccess('contribution', 'repeattransaction', [
2505       'contribution_recur_id' => $contributionRecur['id'],
2506       'contribution_status_id' => 'Completed',
2507       'trxn_id' => 'magic_number',
2508     ]);
2509
2510     $this->assertEquals($contributionRecur['values'][1]['is_test'], $repeatedContribution['values'][2]['is_test']);
2511   }
2512
2513   /**
2514    * CRM-19945 Tests that Contribute.repeattransaction renews a membership when contribution status=Completed
2515    *
2516    * @throws \CRM_Core_Exception
2517    */
2518   public function testRepeatTransactionMembershipRenewCompletedContribution() {
2519     list($originalContribution, $membership) = $this->setUpAutoRenewMembership();
2520
2521     $contribution = $this->callAPISuccess('Contribution', 'repeattransaction', [
2522       'contribution_recur_id' => $originalContribution['values'][1]['contribution_recur_id'],
2523       'contribution_status_id' => 'Failed',
2524     ]);
2525
2526     $this->callAPISuccess('membership', 'create', [
2527       'id' => $membership['id'],
2528       'end_date' => 'yesterday',
2529       'status_id' => 'Expired',
2530     ]);
2531
2532     $contribution = $this->callAPISuccess('Contribution', 'repeattransaction', [
2533       'contribution_recur_id' => $originalContribution['values'][1]['contribution_recur_id'],
2534       'contribution_status_id' => 'Completed',
2535       'trxn_id' => 'bobsled',
2536     ]);
2537
2538     $membershipStatusId = $this->callAPISuccess('membership', 'getvalue', [
2539       'id' => $membership['id'],
2540       'return' => 'status_id',
2541     ]);
2542
2543     $membership = $this->callAPISuccess('membership', 'get', [
2544       'id' => $membership['id'],
2545     ]);
2546
2547     $this->assertEquals('New', CRM_Core_PseudoConstant::getName('CRM_Member_BAO_Membership', 'status_id', $membershipStatusId));
2548
2549     $lineItem = $this->callAPISuccessGetSingle('LineItem', ['contribution_id' => $contribution['id']]);
2550     $this->assertEquals('civicrm_membership', $lineItem['entity_table']);
2551     $this->callAPISuccessGetCount('MembershipPayment', ['membership_id' => $membership['id']]);
2552   }
2553
2554   /**
2555    * This is one of those tests that locks in existing behaviour.
2556    *
2557    * I feel like correct behaviour is arguable & has been discussed in the past. However, if the membership has
2558    * a date which says it should be expired then the result of repeattransaction is to push that date
2559    * to be one membership term from 'now' with status 'new'.
2560    */
2561   public function testRepeattransactionRenewMembershipOldMembership() {
2562     $entities = $this->setUpAutoRenewMembership();
2563     $newStatusID = CRM_Core_PseudoConstant::getKey('CRM_Member_BAO_Membership', 'status_id', 'New');
2564     $membership = $this->callAPISuccess('Membership', 'create', [
2565       'id' => $entities[1]['id'],
2566       'join_date' => '4 months ago',
2567       'start_date' => '3 months ago',
2568       'end_date' => '2 months ago',
2569     ]);
2570     $membership = $membership['values'][$membership['id']];
2571
2572     // This status does not appear to be calculated at all and is set to 'new'. Feels like a bug.
2573     $this->assertEquals($newStatusID, $membership['status_id']);
2574
2575     // So it seems renewing this expired membership results in it's new status being current and it being pushed to a future date
2576     $this->callAPISuccess('Contribution', 'repeattransaction', ['original_contribution_id' => $entities[0]['id'], 'contribution_status_id' => 'Completed']);
2577     $membership = $this->callAPISuccessGetSingle('Membership', ['id' => $membership['id']]);
2578     // If this date calculation winds up being flakey the spirit of the test would be maintained by just checking
2579     // date is greater than today.
2580     $this->assertEquals(date('Y-m-d', strtotime('+ 1 month -1 day')), $membership['end_date']);
2581     $this->assertEquals($newStatusID, $membership['membership_type_id']);
2582   }
2583
2584   /**
2585    * CRM-19945 Tests that Contribute.repeattransaction DOES NOT renew a membership when contribution status=Failed
2586    *
2587    * @dataProvider contributionStatusProvider
2588    *
2589    * @throws \CRM_Core_Exception
2590    */
2591   public function testRepeatTransactionMembershipRenewContributionNotCompleted($contributionStatus) {
2592     // Completed status should renew so we don't test that here
2593     // In Progress status was never actually intended to be available for contributions.
2594     // Partially paid is not valid.
2595     if (in_array($contributionStatus['name'], ['Completed', 'In Progress', 'Partially paid'])) {
2596       return;
2597     }
2598     list($originalContribution, $membership) = $this->setUpAutoRenewMembership();
2599
2600     $this->callAPISuccess('Contribution', 'repeattransaction', [
2601       'original_contribution_id' => $originalContribution['id'],
2602       'contribution_status_id' => 'Completed',
2603     ]);
2604
2605     $this->callAPISuccess('membership', 'create', [
2606       'id' => $membership['id'],
2607       'end_date' => 'yesterday',
2608       'status_id' => 'Expired',
2609     ]);
2610
2611     $contribution = $this->callAPISuccess('contribution', 'repeattransaction', [
2612       'contribution_recur_id' => $originalContribution['values'][1]['contribution_recur_id'],
2613       'contribution_status_id' => $contributionStatus['name'],
2614       'trxn_id' => 'bobsled',
2615     ]);
2616
2617     $updatedMembership = $this->callAPISuccess('membership', 'getsingle', ['id' => $membership['id']]);
2618
2619     $dateTime = new DateTime('yesterday');
2620     $this->assertEquals($dateTime->format('Y-m-d'), $updatedMembership['end_date']);
2621     $this->assertEquals(CRM_Core_PseudoConstant::getKey('CRM_Member_BAO_Membership', 'status_id', 'Expired'), $updatedMembership['status_id']);
2622
2623     $lineItem = $this->callAPISuccessGetSingle('LineItem', ['contribution_id' => $contribution['id']]);
2624     $this->assertEquals('civicrm_membership', $lineItem['entity_table']);
2625     $this->callAPISuccessGetCount('MembershipPayment', ['membership_id' => $membership['id']]);
2626   }
2627
2628   /**
2629    * Dataprovider provides contribution status as [optionvalue=>contribution_status_name]
2630    * FIXME: buildOptions seems to die in CRM_Core_Config::_construct when in test mode.
2631    *
2632    * @return array
2633    * @throws \CiviCRM_API3_Exception
2634    */
2635   public function contributionStatusProvider() {
2636     $contributionStatuses = civicrm_api3('OptionValue', 'get', [
2637       'return' => ["id", "name"],
2638       'option_group_id' => "contribution_status",
2639     ]);
2640     foreach ($contributionStatuses['values'] as $statusName) {
2641       $statuses[] = [$statusName];
2642     }
2643     return $statuses;
2644   }
2645
2646   /**
2647    * CRM-16397 test appropriate action if total amount has changed for single line items.
2648    */
2649   public function testRepeatTransactionAlteredAmount() {
2650     $paymentProcessorID = $this->paymentProcessorCreate();
2651     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', [
2652       'contact_id' => $this->_individualId,
2653       'installments' => '12',
2654       'frequency_interval' => '1',
2655       'amount' => '500',
2656       'contribution_status_id' => 1,
2657       'start_date' => '2012-01-01 00:00:00',
2658       'currency' => 'USD',
2659       'frequency_unit' => 'month',
2660       'payment_processor_id' => $paymentProcessorID,
2661     ]);
2662     $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
2663         $this->_params,
2664         [
2665           'contribution_recur_id' => $contributionRecur['id'],
2666         ])
2667     );
2668
2669     $this->callAPISuccess('contribution', 'repeattransaction', [
2670       'original_contribution_id' => $originalContribution['id'],
2671       'contribution_status_id' => 'Completed',
2672       'trxn_id' => uniqid(),
2673       'total_amount' => '400',
2674       'fee_amount' => 50,
2675     ]);
2676
2677     $lineItemParams = [
2678       'entity_id' => $originalContribution['id'],
2679       'sequential' => 1,
2680       'return' => [
2681         'entity_table',
2682         'qty',
2683         'unit_price',
2684         'line_total',
2685         'label',
2686         'financial_type_id',
2687         'deductible_amount',
2688         'price_field_value_id',
2689         'price_field_id',
2690       ],
2691     ];
2692     $this->callAPISuccessGetSingle('contribution', [
2693       'total_amount' => 400,
2694       'fee_amount' => 50,
2695       'net_amount' => 350,
2696     ]);
2697     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2698       'entity_id' => $originalContribution['id'],
2699     ]));
2700     $expectedLineItem = array_merge(
2701       $lineItem1['values'][0], [
2702         'line_total' => '400.00',
2703         'unit_price' => '400.00',
2704       ]
2705     );
2706
2707     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2708       'entity_id' => $originalContribution['id'] + 1,
2709     ]));
2710
2711     unset($expectedLineItem['id'], $expectedLineItem['entity_id']);
2712     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2713     $this->assertEquals($expectedLineItem, $lineItem2['values'][0]);
2714   }
2715
2716   /**
2717    * Test financial_type_id override behaviour with a single line item.
2718    *
2719    * CRM-17718 a passed in financial_type_id is allowed to override the original contribution where there
2720    * is only one line item.
2721    */
2722   public function testRepeatTransactionPassedInFinancialType() {
2723     $originalContribution = $this->setUpRecurringContribution();
2724
2725     $this->callAPISuccess('contribution', 'repeattransaction', [
2726       'original_contribution_id' => $originalContribution['id'],
2727       'contribution_status_id' => 'Completed',
2728       'trxn_id' => uniqid(),
2729       'financial_type_id' => 2,
2730     ]);
2731     $lineItemParams = [
2732       'entity_id' => $originalContribution['id'],
2733       'sequential' => 1,
2734       'return' => [
2735         'entity_table',
2736         'qty',
2737         'unit_price',
2738         'line_total',
2739         'label',
2740         'financial_type_id',
2741         'deductible_amount',
2742         'price_field_value_id',
2743         'price_field_id',
2744       ],
2745     ];
2746
2747     $this->callAPISuccessGetSingle('Contribution', [
2748       'total_amount' => 100,
2749       'financial_type_id' => 2,
2750     ]);
2751     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2752       'entity_id' => $originalContribution['id'],
2753     ]));
2754     $expectedLineItem = array_merge(
2755       $lineItem1['values'][0], [
2756         'line_total' => '100.00',
2757         'unit_price' => '100.00',
2758         'financial_type_id' => 2,
2759         'contribution_type_id' => 2,
2760       ]
2761     );
2762     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2763       'entity_id' => $originalContribution['id'] + 1,
2764     ]));
2765     unset($expectedLineItem['id'], $expectedLineItem['entity_id']);
2766     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2767     $this->assertEquals($expectedLineItem, $lineItem2['values'][0]);
2768   }
2769
2770   /**
2771    * Test financial_type_id override behaviour with a single line item.
2772    *
2773    * CRM-17718 a passed in financial_type_id is not allowed to override the original contribution where there
2774    * is more than one line item.
2775    */
2776   public function testRepeatTransactionPassedInFinancialTypeTwoLineItems() {
2777     $this->_params = $this->getParticipantOrderParams();
2778     $originalContribution = $this->setUpRecurringContribution();
2779
2780     $this->callAPISuccess('Contribution', 'repeattransaction', [
2781       'original_contribution_id' => $originalContribution['id'],
2782       'contribution_status_id' => 'Completed',
2783       'trxn_id' => 'repeat',
2784       'financial_type_id' => 2,
2785     ]);
2786
2787     // Retrieve the new contribution and note the financial type passed in has been ignored.
2788     $contribution = $this->callAPISuccessGetSingle('Contribution', [
2789       'trxn_id' => 'repeat',
2790     ]);
2791     $this->assertEquals(4, $contribution['financial_type_id']);
2792
2793     $lineItems = $this->callAPISuccess('line_item', 'get', [
2794       'entity_id' => $contribution['id'],
2795     ])['values'];
2796     foreach ($lineItems as $lineItem) {
2797       $this->assertNotEquals(2, $lineItem['financial_type_id']);
2798     }
2799   }
2800
2801   /**
2802    * CRM-17718 test appropriate action if financial type has changed for single line items.
2803    */
2804   public function testRepeatTransactionUpdatedFinancialType() {
2805     $originalContribution = $this->setUpRecurringContribution([], ['financial_type_id' => 2]);
2806
2807     $this->callAPISuccess('contribution', 'repeattransaction', [
2808       'contribution_recur_id' => $originalContribution['id'],
2809       'contribution_status_id' => 'Completed',
2810       'trxn_id' => uniqid(),
2811     ]);
2812     $lineItemParams = [
2813       'entity_id' => $originalContribution['id'],
2814       'sequential' => 1,
2815       'return' => [
2816         'entity_table',
2817         'qty',
2818         'unit_price',
2819         'line_total',
2820         'label',
2821         'financial_type_id',
2822         'deductible_amount',
2823         'price_field_value_id',
2824         'price_field_id',
2825       ],
2826     ];
2827
2828     $this->callAPISuccessGetSingle('contribution', [
2829       'total_amount' => 100,
2830       'financial_type_id' => 2,
2831     ]);
2832     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2833       'entity_id' => $originalContribution['id'],
2834     ]));
2835     $expectedLineItem = array_merge(
2836       $lineItem1['values'][0], [
2837         'line_total' => '100.00',
2838         'unit_price' => '100.00',
2839         'financial_type_id' => 2,
2840         'contribution_type_id' => 2,
2841       ]
2842     );
2843
2844     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2845       'entity_id' => $originalContribution['id'] + 1,
2846     ]));
2847     unset($expectedLineItem['id'], $expectedLineItem['entity_id']);
2848     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2849     $this->assertEquals($expectedLineItem, $lineItem2['values'][0]);
2850   }
2851
2852   /**
2853    * CRM-16397 test appropriate action if campaign has been passed in.
2854    */
2855   public function testRepeatTransactionPassedInCampaign() {
2856     $paymentProcessorID = $this->paymentProcessorCreate();
2857     $campaignID = $this->campaignCreate();
2858     $campaignID2 = $this->campaignCreate();
2859     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', [
2860       'contact_id' => $this->_individualId,
2861       'installments' => '12',
2862       'frequency_interval' => '1',
2863       'amount' => '100',
2864       'contribution_status_id' => 1,
2865       'start_date' => '2012-01-01 00:00:00',
2866       'currency' => 'USD',
2867       'frequency_unit' => 'month',
2868       'payment_processor_id' => $paymentProcessorID,
2869     ]);
2870     $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
2871       $this->_params,
2872       [
2873         'contribution_recur_id' => $contributionRecur['id'],
2874         'campaign_id' => $campaignID,
2875       ])
2876     );
2877
2878     $this->callAPISuccess('contribution', 'repeattransaction', [
2879       'original_contribution_id' => $originalContribution['id'],
2880       'contribution_status_id' => 'Completed',
2881       'trxn_id' => uniqid(),
2882       'campaign_id' => $campaignID2,
2883     ]);
2884
2885     $this->callAPISuccessGetSingle('contribution', [
2886       'total_amount' => 100,
2887       'campaign_id' => $campaignID2,
2888     ]);
2889   }
2890
2891   /**
2892    * CRM-17718 campaign stored on contribution recur gets priority.
2893    *
2894    * This reflects the fact we permit people to update them.
2895    */
2896   public function testRepeatTransactionUpdatedCampaign() {
2897     $paymentProcessorID = $this->paymentProcessorCreate();
2898     $campaignID = $this->campaignCreate();
2899     $campaignID2 = $this->campaignCreate();
2900     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', [
2901       'contact_id' => $this->_individualId,
2902       'installments' => '12',
2903       'frequency_interval' => '1',
2904       'amount' => '100',
2905       'contribution_status_id' => 1,
2906       'start_date' => '2012-01-01 00:00:00',
2907       'currency' => 'USD',
2908       'frequency_unit' => 'month',
2909       'payment_processor_id' => $paymentProcessorID,
2910       'campaign_id' => $campaignID,
2911     ]);
2912     $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
2913       $this->_params,
2914       [
2915         'contribution_recur_id' => $contributionRecur['id'],
2916         'campaign_id' => $campaignID2,
2917       ])
2918     );
2919
2920     $this->callAPISuccess('contribution', 'repeattransaction', [
2921       'original_contribution_id' => $originalContribution['id'],
2922       'contribution_status_id' => 'Completed',
2923       'trxn_id' => uniqid(),
2924     ]);
2925
2926     $this->callAPISuccessGetSingle('contribution', [
2927       'total_amount' => 100,
2928       'campaign_id' => $campaignID,
2929     ]);
2930   }
2931
2932   /**
2933    * CRM-20685 Repeattransaction produces incorrect Financial Type ID (in specific circumstance) - if number of lineItems = 1.
2934    *
2935    * This case happens when the line item & contribution do not have the same type in his initiating transaction.
2936    */
2937   public function testRepeatTransactionUpdatedFinancialTypeAndNotEquals() {
2938     $originalContribution = $this->setUpRecurringContribution([], ['financial_type_id' => 2]);
2939     // This will made the trick to get the not equals behaviour.
2940     $this->callAPISuccess('line_item', 'create', ['id' => 1, 'financial_type_id' => 4]);
2941     $this->callAPISuccess('contribution', 'repeattransaction', [
2942       'contribution_recur_id' => $originalContribution['id'],
2943       'contribution_status_id' => 'Completed',
2944       'trxn_id' => uniqid(),
2945     ]);
2946     $lineItemParams = [
2947       'entity_id' => $originalContribution['id'],
2948       'sequential' => 1,
2949       'return' => [
2950         'entity_table',
2951         'qty',
2952         'unit_price',
2953         'line_total',
2954         'label',
2955         'financial_type_id',
2956         'deductible_amount',
2957         'price_field_value_id',
2958         'price_field_id',
2959       ],
2960     ];
2961     $this->callAPISuccessGetSingle('contribution', [
2962       'total_amount' => 100,
2963       'financial_type_id' => 2,
2964     ]);
2965     $lineItem1 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2966       'entity_id' => $originalContribution['id'],
2967     ]));
2968     $expectedLineItem = array_merge(
2969       $lineItem1['values'][0], [
2970         'line_total' => '100.00',
2971         'unit_price' => '100.00',
2972         'financial_type_id' => 4,
2973         'contribution_type_id' => 4,
2974       ]
2975     );
2976
2977     $lineItem2 = $this->callAPISuccess('line_item', 'get', array_merge($lineItemParams, [
2978       'entity_id' => $originalContribution['id'] + 1,
2979     ]));
2980     $this->callAPISuccess('line_item', 'create', ['id' => 1, 'financial_type_id' => 1]);
2981     unset($expectedLineItem['id'], $expectedLineItem['entity_id']);
2982     unset($lineItem2['values'][0]['id'], $lineItem2['values'][0]['entity_id']);
2983     $this->assertEquals($expectedLineItem, $lineItem2['values'][0]);
2984   }
2985
2986   /**
2987    * Test completing a transaction does not 'mess' with net amount (CRM-15960).
2988    */
2989   public function testCompleteTransactionNetAmountOK() {
2990     $this->createLoggedInUser();
2991     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
2992     unset($params['net_amount']);
2993     $contribution = $this->callAPISuccess('contribution', 'create', $params);
2994     $this->callAPISuccess('contribution', 'completetransaction', [
2995       'id' => $contribution['id'],
2996     ]);
2997     $contribution = $this->callAPISuccess('contribution', 'getsingle', ['id' => $contribution['id']]);
2998     $this->assertEquals('Completed', $contribution['contribution_status']);
2999     $this->assertTrue(($contribution['total_amount'] - $contribution['net_amount']) == $contribution['fee_amount']);
3000   }
3001
3002   /**
3003    * CRM-14151 - Test completing a transaction via the API.
3004    */
3005   public function testCompleteTransactionWithReceiptDateSet() {
3006     $this->swapMessageTemplateForTestTemplate();
3007     $mut = new CiviMailUtils($this, TRUE);
3008     $this->createLoggedInUser();
3009     $params = array_merge($this->_params, ['contribution_status_id' => 2, 'receipt_date' => 'now']);
3010     $contribution = $this->callAPISuccess('contribution', 'create', $params);
3011     $this->callAPISuccess('contribution', 'completetransaction', ['id' => $contribution['id'], 'trxn_date' => date('Y-m-d')]);
3012     $contribution = $this->callAPISuccess('contribution', 'get', ['id' => $contribution['id'], 'sequential' => 1]);
3013     $this->assertEquals('Completed', $contribution['values'][0]['contribution_status']);
3014     // Make sure receive_date is original date and make sure payment date is today
3015     $this->assertEquals('2012-05-11', date('Y-m-d', strtotime($contribution['values'][0]['receive_date'])));
3016     $payment = $this->callAPISuccess('payment', 'get', ['contribution_id' => $contribution['id'], 'sequential' => 1]);
3017     $this->assertEquals(date('Y-m-d'), date('Y-m-d', strtotime($payment['values'][0]['trxn_date'])));
3018     $mut->checkMailLog([
3019       'Receipt - Contribution',
3020       'receipt_date:::' . date('Ymd'),
3021     ]);
3022     $mut->stop();
3023     $this->revertTemplateToReservedTemplate();
3024   }
3025
3026   /**
3027    * CRM-1960 - Test to ensure that completetransaction respects the is_email_receipt setting
3028    */
3029   public function testCompleteTransactionWithEmailReceiptInput() {
3030     $contributionPage = $this->createReceiptableContributionPage();
3031
3032     $this->_params['contribution_page_id'] = $contributionPage['id'];
3033     $params = array_merge($this->_params, ['contribution_status_id' => 2]);
3034     $contribution = $this->callAPISuccess('contribution', 'create', $params);
3035     // Complete the transaction overriding is_email_receipt to = FALSE
3036     $this->callAPISuccess('contribution', 'completetransaction', [
3037       'id' => $contribution['id'],
3038       'trxn_date' => date('2011-04-09'),
3039       'trxn_id' => 'kazam',
3040       'is_email_receipt' => 0,
3041     ]);
3042     // Check if a receipt was issued
3043     $receipt_date = $this->callAPISuccess('Contribution', 'getvalue', ['id' => $contribution['id'], 'return' => 'receipt_date']);
3044     $this->assertEquals('', $receipt_date);
3045   }
3046
3047   /**
3048    * Test that $is_recur is assigned to the receipt.
3049    */
3050   public function testCompleteTransactionForRecurring() {
3051     $this->mut = new CiviMailUtils($this, TRUE);
3052     $this->swapMessageTemplateForTestTemplate();
3053     $recurring = $this->setUpRecurringContribution();
3054     $contributionPage = $this->createReceiptableContributionPage(['is_recur' => TRUE, 'recur_frequency_unit' => 'month', 'recur_interval' => 1]);
3055
3056     $this->_params['contribution_page_id'] = $contributionPage['id'];
3057     $this->_params['contribution_recur_id'] = $recurring['id'];
3058
3059     $contribution = $this->setUpForCompleteTransaction();
3060
3061     $this->callAPISuccess('contribution', 'completetransaction', [
3062       'id' => $contribution['id'],
3063       'trxn_date' => date('2011-04-09'),
3064       'trxn_id' => 'kazam',
3065       'is_email_receipt' => 1,
3066     ]);
3067
3068     $this->mut->checkMailLog([
3069       'is_recur:::1',
3070       'cancelSubscriptionUrl:::' . CIVICRM_UF_BASEURL,
3071     ]);
3072     $this->mut->stop();
3073     $this->revertTemplateToReservedTemplate();
3074   }
3075
3076   /**
3077    * CRM-19710 - Test to ensure that completetransaction respects the input for is_email_receipt setting.
3078    *
3079    * If passed in it will override the default from contribution page.
3080    */
3081   public function testCompleteTransactionWithEmailReceiptInputTrue() {
3082     $mut = new CiviMailUtils($this, TRUE);
3083     $this->createLoggedInUser();
3084     // Create a Contribution Page with is_email_receipt = FALSE
3085     $contributionPage = $this->callAPISuccess('ContributionPage', 'create', [
3086       'receipt_from_name' => 'Mickey Mouse',
3087       'receipt_from_email' => 'mickey@mouse.com',
3088       'title' => "Test Contribution Page",
3089       'financial_type_id' => 1,
3090       'currency' => 'CAD',
3091       'is_monetary' => TRUE,
3092       'is_email_receipt' => 0,
3093     ]);
3094     $this->_params['contribution_page_id'] = $contributionPage['id'];
3095     $params = array_merge($this->_params, ['contribution_status_id' => 2, 'receipt_date' => 'now']);
3096     $contribution = $this->callAPISuccess('contribution', 'create', $params);
3097     // Complete the transaction overriding is_email_receipt to = TRUE
3098     $this->callAPISuccess('contribution', 'completetransaction', [
3099       'id' => $contribution['id'],
3100       'is_email_receipt' => 1,
3101     ]);
3102     $mut->checkMailLog([
3103       'Contribution Information',
3104     ]);
3105     $mut->stop();
3106   }
3107
3108   /**
3109    * Complete the transaction using the template with all the possible.
3110    */
3111   public function testCompleteTransactionWithTestTemplate() {
3112     $this->swapMessageTemplateForTestTemplate();
3113     $contribution = $this->setUpForCompleteTransaction();
3114     $this->callAPISuccess('contribution', 'completetransaction', [
3115       'id' => $contribution['id'],
3116       'trxn_date' => date('2011-04-09'),
3117       'trxn_id' => 'kazam',
3118     ]);
3119     $receive_date = $this->callAPISuccess('Contribution', 'getvalue', ['id' => $contribution['id'], 'return' => 'receive_date']);
3120     $this->mut->checkMailLog([
3121       'email:::anthony_anderson@civicrm.org',
3122       'is_monetary:::1',
3123       'amount:::100.00',
3124       'currency:::USD',
3125       'receive_date:::' . date('Ymd', strtotime($receive_date)),
3126       'receipt_date:::' . date('Ymd'),
3127       'contributeMode:::notify',
3128       'title:::Contribution',
3129       'displayName:::Mr. Anthony Anderson II',
3130       'trxn_id:::kazam',
3131       'contactID:::' . $this->_params['contact_id'],
3132       'contributionID:::' . $contribution['id'],
3133       'financialTypeId:::1',
3134       'financialTypeName:::Donation',
3135     ]);
3136     $this->mut->stop();
3137     $this->revertTemplateToReservedTemplate();
3138   }
3139
3140   /**
3141    * Complete the transaction using the template with all the possible.
3142    */
3143   public function testCompleteTransactionContributionPageFromAddress() {
3144     $contributionPage = $this->callAPISuccess('ContributionPage', 'create', [
3145       'receipt_from_name' => 'Mickey Mouse',
3146       'receipt_from_email' => 'mickey@mouse.com',
3147       'title' => "Test Contribution Page",
3148       'financial_type_id' => 1,
3149       'currency' => 'NZD',
3150       'goal_amount' => 50,
3151       'is_pay_later' => 1,
3152       'is_monetary' => TRUE,
3153       'is_email_receipt' => TRUE,
3154     ]);
3155     $this->_params['contribution_page_id'] = $contributionPage['id'];
3156     $contribution = $this->setUpForCompleteTransaction();
3157     $this->callAPISuccess('contribution', 'completetransaction', ['id' => $contribution['id']]);
3158     $this->mut->checkMailLog([
3159       'mickey@mouse.com',
3160       'Mickey Mouse <',
3161     ]);
3162     $this->mut->stop();
3163   }
3164
3165   /**
3166    * Test completing first transaction in a recurring series.
3167    *
3168    * The status should be set to 'in progress' and the next scheduled payment date calculated.
3169    *
3170    * @dataProvider getScheduledDateData
3171    *
3172    * @param array $dataSet
3173    *
3174    * @throws \Exception
3175    */
3176   public function testCompleteTransactionSetStatusToInProgress($dataSet) {
3177     $paymentProcessorID = $this->paymentProcessorCreate();
3178     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge([
3179       'contact_id' => $this->_individualId,
3180       'installments' => '2',
3181       'frequency_interval' => '1',
3182       'amount' => '500',
3183       'contribution_status_id' => 'Pending',
3184       'start_date' => '2012-01-01 00:00:00',
3185       'currency' => 'USD',
3186       'frequency_unit' => 'month',
3187       'payment_processor_id' => $paymentProcessorID,
3188     ], $dataSet['data']));
3189     $contribution = $this->callAPISuccess('contribution', 'create', array_merge(
3190       $this->_params,
3191       [
3192         'contribution_recur_id' => $contributionRecur['id'],
3193         'contribution_status_id' => 'Pending',
3194         'receive_date' => $dataSet['receive_date'],
3195       ])
3196     );
3197     $this->callAPISuccess('Contribution', 'completetransaction', [
3198       'id' => $contribution,
3199       'receive_date' => $dataSet['receive_date'],
3200     ]);
3201     $contributionRecur = $this->callAPISuccessGetSingle('ContributionRecur', [
3202       'id' => $contributionRecur['id'],
3203       'return' => ['next_sched_contribution_date', 'contribution_status_id'],
3204     ]);
3205     $this->assertEquals(5, $contributionRecur['contribution_status_id']);
3206     $this->assertEquals($dataSet['expected'], $contributionRecur['next_sched_contribution_date']);
3207     $this->callAPISuccess('Contribution', 'create', array_merge(
3208       $this->_params,
3209       [
3210         'contribution_recur_id' => $contributionRecur['id'],
3211         'contribution_status_id' => 'Completed',
3212       ]
3213     ));
3214     $contributionRecur = $this->callAPISuccessGetSingle('ContributionRecur', [
3215       'id' => $contributionRecur['id'],
3216       'return' => ['contribution_status_id'],
3217     ]);
3218     $this->assertEquals(1, $contributionRecur['contribution_status_id']);
3219   }
3220
3221   /**
3222    * Get dates for testing.
3223    *
3224    * @return array
3225    */
3226   public function getScheduledDateData() {
3227     $result = [];
3228     $result[]['2016-08-31-1-month'] = [
3229       'data' => [
3230         'start_date' => '2016-08-31',
3231         'frequency_interval' => 1,
3232         'frequency_unit' => 'month',
3233       ],
3234       'receive_date' => '2016-08-31',
3235       'expected' => '2016-10-01 00:00:00',
3236     ];
3237     $result[]['2012-01-01-1-month'] = [
3238       'data' => [
3239         'start_date' => '2012-01-01',
3240         'frequency_interval' => 1,
3241         'frequency_unit' => 'month',
3242       ],
3243       'receive_date' => '2012-01-01',
3244       'expected' => '2012-02-01 00:00:00',
3245     ];
3246     $result[]['2012-01-01-1-month'] = [
3247       'data' => [
3248         'start_date' => '2012-01-01',
3249         'frequency_interval' => 1,
3250         'frequency_unit' => 'month',
3251       ],
3252       'receive_date' => '2012-02-29',
3253       'expected' => '2012-03-29 00:00:00',
3254     ];
3255     $result['receive_date_includes_time']['2012-01-01-1-month'] = [
3256       'data' => [
3257         'start_date' => '2012-01-01',
3258         'frequency_interval' => 1,
3259         'frequency_unit' => 'month',
3260         'next_sched_contribution_date' => '2012-02-29',
3261       ],
3262       'receive_date' => '2012-02-29 16:00:00',
3263       'expected' => '2012-03-29 00:00:00',
3264     ];
3265     return $result;
3266   }
3267
3268   /**
3269    * Test completing a pledge with the completeTransaction api..
3270    *
3271    * Note that we are creating a logged in user because email goes out from
3272    * that person.
3273    */
3274   public function testCompleteTransactionUpdatePledgePayment() {
3275     $this->swapMessageTemplateForTestTemplate();
3276     $mut = new CiviMailUtils($this, TRUE);
3277     $mut->clearMessages();
3278     $this->createLoggedInUser();
3279     $contributionID = $this->createPendingPledgeContribution();
3280     $this->callAPISuccess('contribution', 'completetransaction', [
3281       'id' => $contributionID,
3282       'trxn_date' => '1 Feb 2013',
3283     ]);
3284     $pledge = $this->callAPISuccessGetSingle('Pledge', [
3285       'id' => $this->_ids['pledge'],
3286     ]);
3287     $this->assertEquals('Completed', $pledge['pledge_status']);
3288
3289     $status = $this->callAPISuccessGetValue('PledgePayment', [
3290       'pledge_id' => $this->_ids['pledge'],
3291       'return' => 'status_id',
3292     ]);
3293     $this->assertEquals(1, $status);
3294     $mut->checkMailLog([
3295       'amount:::500.00',
3296       // The `receive_date` should remain as it was created.
3297       // TODO: the latest payment transaction date (and maybe other details,
3298       // such as amount and payment instrument) would be a useful token to make
3299       // available.
3300       'receive_date:::20120511000000',
3301       "receipt_date:::\n",
3302     ]);
3303     $mut->stop();
3304     $this->revertTemplateToReservedTemplate();
3305   }
3306
3307   /**
3308    * Test completing a transaction with an event via the API.
3309    *
3310    * Note that we are creating a logged in user because email goes out from
3311    * that person
3312    *
3313    * @throws \CRM_Core_Exception
3314    */
3315   public function testCompleteTransactionWithParticipantRecord() {
3316     $mut = new CiviMailUtils($this, TRUE);
3317     $mut->clearMessages();
3318     $this->_individualId = $this->createLoggedInUser();
3319     $contributionID = $this->createPendingParticipantContribution();
3320     $this->createJoinedProfile(['entity_id' => $this->_ids['event']['test'], 'entity_table' => 'civicrm_event']);
3321     $this->createJoinedProfile(['entity_id' => $this->_ids['event']['test'], 'entity_table' => 'civicrm_event', 'weight' => 2], ['name' => 'post_1', 'title' => 'title_post_2', 'frontend_title' => 'public 2']);
3322     $this->createJoinedProfile(['entity_id' => $this->_ids['event']['test'], 'entity_table' => 'civicrm_event', 'weight' => 3], ['name' => 'post_2', 'title' => 'title_post_3', 'frontend_title' => 'public 3']);
3323     $this->eliminateUFGroupOne();
3324
3325     $this->callAPISuccess('contribution', 'completetransaction', [
3326       'id' => $contributionID,
3327     ]
3328     );
3329     $participantStatus = $this->callAPISuccessGetValue('participant', [
3330       'id' => $this->_ids['participant'],
3331       'return' => 'participant_status_id',
3332     ]);
3333     $this->assertEquals(1, $participantStatus);
3334
3335     //Assert only three activities are created.
3336     $activities = $this->callAPISuccess('Activity', 'get', [
3337       'contact_id' => $this->_individualId,
3338     ])['values'];
3339
3340     $this->assertCount(3, $activities);
3341     $activityNames = array_count_values(CRM_Utils_Array::collect('activity_name', $activities));
3342     // record two activities before and after completing payment for Event registration
3343     $this->assertEquals(2, $activityNames['Event Registration']);
3344     // update the original 'Contribution' activity created after completing payment
3345     $this->assertEquals(1, $activityNames['Contribution']);
3346
3347     $mut->checkMailLog([
3348       'Annual CiviCRM meet',
3349       'Event',
3350       'This is a confirmation that your registration has been received and your status has been updated to Registered.',
3351       'First Name: Logged In',
3352       'Public title',
3353       'public 2',
3354       'public 3',
3355     ], ['Back end title', 'title_post_2', 'title_post_3']);
3356     $mut->stop();
3357   }
3358
3359   /**
3360    * Test membership is renewed when transaction completed.
3361    */
3362   public function testCompleteTransactionMembershipPriceSet() {
3363     $this->createPriceSetWithPage('membership');
3364     $stateOfGrace = $this->callAPISuccess('MembershipStatus', 'getvalue', [
3365       'name' => 'Grace',
3366       'return' => 'id',
3367     ]);
3368     $this->setUpPendingContribution($this->_ids['price_field_value'][0]);
3369     $membership = $this->callAPISuccess('membership', 'getsingle', ['id' => $this->_ids['membership']]);
3370     $logs = $this->callAPISuccess('MembershipLog', 'get', [
3371       'membership_id' => $this->_ids['membership'],
3372     ]);
3373     $this->assertEquals(1, $logs['count']);
3374     $this->assertEquals($stateOfGrace, $membership['status_id']);
3375     $this->callAPISuccess('contribution', 'completetransaction', ['id' => $this->_ids['contribution']]);
3376     $membership = $this->callAPISuccess('membership', 'getsingle', ['id' => $this->_ids['membership']]);
3377     $this->assertEquals(date('Y-m-d', strtotime('yesterday + 1 year')), $membership['end_date']);
3378     $this->callAPISuccessGetSingle('LineItem', [
3379       'entity_id' => $this->_ids['membership'],
3380       'entity_table' => 'civicrm_membership',
3381     ]);
3382     $logs = $this->callAPISuccess('MembershipLog', 'get', [
3383       'membership_id' => $this->_ids['membership'],
3384     ]);
3385     $this->assertEquals(2, $logs['count']);
3386     $this->assertNotEquals($stateOfGrace, $logs['values'][2]['status_id']);
3387     //Assert only three activities are created.
3388     $activities = CRM_Activity_BAO_Activity::getContactActivity($this->_ids['contact']);
3389     $this->assertEquals(3, count($activities));
3390     $activityNames = array_flip(CRM_Utils_Array::collect('activity_name', $activities));
3391     $this->assertArrayHasKey('Contribution', $activityNames);
3392     $this->assertArrayHasKey('Membership Signup', $activityNames);
3393     $this->assertArrayHasKey('Change Membership Status', $activityNames);
3394     $this->cleanUpAfterPriceSets();
3395   }
3396
3397   /**
3398    * Test if renewal activity is create after changing Pending contribution to Completed via offline
3399    */
3400   public function testPendingToCompleteContribution() {
3401     $this->createPriceSetWithPage('membership');
3402     $this->setUpPendingContribution($this->_ids['price_field_value'][0]);
3403     $this->callAPISuccess('membership', 'getsingle', ['id' => $this->_ids['membership']]);
3404     // Case 1: Assert that Membership Signup Activity is created on Pending to Completed Contribution via backoffice
3405     $activity = $this->callAPISuccess('Activity', 'get', [
3406       'activity_type_id' => 'Membership Signup',
3407       'source_record_id' => $this->_ids['membership'],
3408       'status_id' => 'Scheduled',
3409     ]);
3410     $this->assertEquals(1, $activity['count']);
3411
3412     // change pending contribution to completed
3413     $form = new CRM_Contribute_Form_Contribution();
3414
3415     $form->_params = [
3416       'id' => $this->_ids['contribution'],
3417       'total_amount' => 20,
3418       'net_amount' => 20,
3419       'fee_amount' => 0,
3420       'financial_type_id' => 1,
3421       'contact_id' => $this->_individualId,
3422       'contribution_status_id' => 1,
3423       'billing_middle_name' => '',
3424       'billing_last_name' => 'Adams',
3425       'billing_street_address-5' => '790L Lincoln St S',
3426       'billing_city-5' => 'Maryknoll',
3427       'billing_state_province_id-5' => 1031,
3428       'billing_postal_code-5' => 10545,
3429       'billing_country_id-5' => 1228,
3430       'frequency_interval' => 1,
3431       'frequency_unit' => 'month',
3432       'installments' => '',
3433       'hidden_AdditionalDetail' => 1,
3434       'hidden_Premium' => 1,
3435       'from_email_address' => '"civi45" <civi45@civicrm.com>',
3436       'receipt_date' => '',
3437       'receipt_date_time' => '',
3438       'payment_processor_id' => $this->paymentProcessorID,
3439       'currency' => 'USD',
3440       'contribution_page_id' => $this->_ids['contribution_page'],
3441       'contribution_mode' => 'membership',
3442       'source' => 'Membership Signup and Renewal',
3443     ];
3444
3445     $form->testSubmit($form->_params, CRM_Core_Action::UPDATE);
3446
3447     // Case 2: After successful payment for Pending backoffice there are three activities created
3448     //  2.a Update status of existing Scheduled Membership Signup (created in step 1) to Completed
3449     $activity = $this->callAPISuccess('Activity', 'get', [
3450       'activity_type_id' => 'Membership Signup',
3451       'source_record_id' => $this->_ids['membership'],
3452       'status_id' => 'Completed',
3453     ]);
3454     $this->assertEquals(1, $activity['count']);
3455     // 2.b Contribution activity created to record successful payment
3456     $activity = $this->callAPISuccess('Activity', 'get', [
3457       'activity_type_id' => 'Contribution',
3458       'source_record_id' => $this->_ids['contribution'],
3459       'status_id' => 'Completed',
3460     ]);
3461     $this->assertEquals(1, $activity['count']);
3462
3463     // 2.c 'Change membership type' activity created to record Membership status change from Grace to Current
3464     $activity = $this->callAPISuccess('Activity', 'get', [
3465       'activity_type_id' => 'Change Membership Status',
3466       'source_record_id' => $this->_ids['membership'],
3467       'status_id' => 'Completed',
3468     ]);
3469     $this->assertEquals(1, $activity['count']);
3470     $this->assertEquals('Status changed from Grace to Current', $activity['values'][$activity['id']]['subject']);
3471
3472     //Create another pending contribution for renewal
3473     $contribution = $this->callAPISuccess('contribution', 'create', [
3474       'domain_id' => 1,
3475       'contact_id' => $this->_ids['contact'],
3476       'receive_date' => date('Ymd'),
3477       'total_amount' => 20.00,
3478       'financial_type_id' => 1,
3479       'payment_instrument_id' => 'Credit Card',
3480       'non_deductible_amount' => 10.00,
3481       'trxn_id' => 'rdhfi88',
3482       'invoice_id' => 'dofhiewuyr',
3483       'source' => 'SSF',
3484       'contribution_status_id' => 2,
3485       'contribution_page_id' => $this->_ids['contribution_page'],
3486       // We can't rely on contribution api to link line items correctly to membership
3487       'skipLineItem' => TRUE,
3488       'api.membership_payment.create' => ['membership_id' => $this->_ids['membership']],
3489     ]);
3490
3491     $this->callAPISuccess('line_item', 'create', [
3492       'entity_id' => $contribution['id'],
3493       'entity_table' => 'civicrm_contribution',
3494       'contribution_id' => $contribution['id'],
3495       'price_field_id' => $this->_ids['price_field'][0],
3496       'qty' => 1,
3497       'unit_price' => 20,
3498       'line_total' => 20,
3499       'financial_type_id' => 1,
3500       'price_field_value_id' => $this->_ids['price_field_value']['cont'],
3501     ]);
3502     $this->callAPISuccess('line_item', 'create', [
3503       'entity_id' => $this->_ids['membership'],
3504       'entity_table' => 'civicrm_membership',
3505       'contribution_id' => $contribution['id'],
3506       'price_field_id' => $this->_ids['price_field'][0],
3507       'qty' => 1,
3508       'unit_price' => 20,
3509       'line_total' => 20,
3510       'financial_type_id' => 1,
3511       'price_field_value_id' => $this->_ids['price_field_value'][0],
3512       'membership_type_id' => $this->_ids['membership_type'],
3513     ]);
3514
3515     //Update it to Failed.
3516     $form->_params['id'] = $contribution['id'];
3517     $form->_params['contribution_status_id'] = 4;
3518
3519     $form->testSubmit($form->_params, CRM_Core_Action::UPDATE);
3520     //Existing membership should not get updated to expired.
3521     $membership = $this->callAPISuccess('membership', 'getsingle', ['id' => $this->_ids['membership']]);
3522     $this->assertNotEquals($membership['status_id'], 4);
3523   }
3524
3525   /**
3526    * Test membership is renewed when transaction completed.
3527    */
3528   public function testCompleteTransactionMembershipPriceSetTwoTerms() {
3529     $this->createPriceSetWithPage('membership');
3530     $this->setUpPendingContribution($this->_ids['price_field_value'][1]);
3531     $this->callAPISuccess('contribution', 'completetransaction', ['id' => $this->_ids['contribution']]);
3532     $membership = $this->callAPISuccess('membership', 'getsingle', ['id' => $this->_ids['membership']]);
3533     $this->assertEquals(date('Y-m-d', strtotime('yesterday + 2 years')), $membership['end_date']);
3534     $this->cleanUpAfterPriceSets();
3535   }
3536
3537   public function cleanUpAfterPriceSets() {
3538     $this->quickCleanUpFinancialEntities();
3539     $this->contactDelete($this->_ids['contact']);
3540   }
3541
3542   /**
3543    * Set up a pending transaction with a specific price field id.
3544    *
3545    * @param int $priceFieldValueID
3546    * @param array $contriParams
3547    */
3548   public function setUpPendingContribution($priceFieldValueID, $contriParams = []) {
3549     $contactID = $this->individualCreate();
3550     $membership = $this->callAPISuccess('membership', 'create', [
3551       'contact_id' => $contactID,
3552       'membership_type_id' => $this->_ids['membership_type'],
3553       'start_date' => 'yesterday - 1 year',
3554       'end_date' => 'yesterday',
3555       'join_date' => 'yesterday - 1 year',
3556     ]);
3557     $contribution = $this->callAPISuccess('contribution', 'create', array_merge([
3558       'domain_id' => 1,
3559       'contact_id' => $contactID,
3560       'receive_date' => date('Ymd'),
3561       'total_amount' => 20.00,
3562       'financial_type_id' => 1,
3563       'payment_instrument_id' => 'Credit Card',
3564       'non_deductible_amount' => 10.00,
3565       'trxn_id' => 'jdhfi' . rand(1, 100),
3566       'invoice_id' => 'djfhiew' . rand(5, 100),
3567       'source' => 'SSF',
3568       'contribution_status_id' => 2,
3569       'contribution_page_id' => $this->_ids['contribution_page'],
3570       'api.membership_payment.create' => ['membership_id' => $membership['id']],
3571     ], $contriParams));
3572
3573     $this->callAPISuccess('line_item', 'create', [
3574       'entity_id' => $contribution['id'],
3575       'entity_table' => 'civicrm_contribution',
3576       'contribution_id' => $contribution['id'],
3577       'price_field_id' => $this->_ids['price_field'][0],
3578       'qty' => 1,
3579       'unit_price' => 20,
3580       'line_total' => 20,
3581       'financial_type_id' => 1,
3582       'price_field_value_id' => $priceFieldValueID,
3583     ]);
3584     $this->_ids['contact'] = $contactID;
3585     $this->_ids['contribution'] = $contribution['id'];
3586     $this->_ids['membership'] = $membership['id'];
3587   }
3588
3589   /**
3590    * Test sending a mail via the API.
3591    *
3592    * @throws \CRM_Core_Exception
3593    * @throws \CiviCRM_API3_Exception
3594    */
3595   public function testSendMail() {
3596     $mut = new CiviMailUtils($this, TRUE);
3597     $orderParams = $this->_params;
3598     $orderParams['contribution_status_id'] = 'Pending';
3599     $orderParams['api.PaymentProcessor.pay'] = [
3600       'payment_processor_id' => $this->paymentProcessorID,
3601       'credit_card_type' => 'Visa',
3602       'credit_card_number' => 41111111111111,
3603       'amount' => 5,
3604     ];
3605
3606     $order = $this->callAPISuccess('Order', 'create', $orderParams);
3607     $this->callAPISuccess('Payment', 'create', ['total_amount' => 5, 'is_send_notification' => 0, 'order_id' => $order['id']]);
3608     $address = $this->callAPISuccess('Address', 'create', ['contribution_id' => $order['id'], 'name' => 'bob', 'contact_id' => 1, 'street_address' => 'blah']);
3609     $this->callAPISuccess('Contribution', 'create', ['id' => $order['id'], 'address_id' => $address['id']]);
3610     $this->callAPISuccess('contribution', 'sendconfirmation', [
3611       'id' => $order['id'],
3612       'receipt_from_email' => 'api@civicrm.org',
3613     ]);
3614     $mut->checkMailLog([
3615       '$ 100.00',
3616       'Contribution Information',
3617     ], [
3618       'Event',
3619     ]);
3620
3621     $this->checkCreditCardDetails($mut, $order['id']);
3622     $mut->stop();
3623     $tplVars = CRM_Core_Smarty::singleton()->get_template_vars();
3624     $this->assertEquals('bob', $tplVars['billingName']);
3625     $this->assertEquals("bob\nblah\n", $tplVars['address']);
3626   }
3627
3628   /**
3629    * Test sending a mail via the API.
3630    * This simulates webform_civicrm using pay later contribution page
3631    */
3632   public function testSendconfirmationPayLater() {
3633     $mut = new CiviMailUtils($this, TRUE);
3634
3635     // Create contribution page
3636     $pageParams = [
3637       'title' => 'Webform Contributions',
3638       'financial_type_id' => 1,
3639       'contribution_type_id' => 1,
3640       'is_confirm_enabled' => 1,
3641       'is_pay_later' => 1,
3642       'pay_later_text' => 'I will send payment by cheque',
3643       'pay_later_receipt' => 'Send your cheque payable to "CiviCRM LLC" to the office',
3644     ];
3645     $contributionPage = $this->callAPISuccess('contribution_page', 'create', $pageParams);
3646
3647     // Create pay later contribution
3648     $contribParams = [
3649       'contact_id' => $this->_individualId,
3650       'financial_type_id' => 1,
3651       'is_pay_later' => 1,
3652       'contribution_status_id' => 2,
3653       'contribution_page_id' => $contributionPage['id'],
3654       'total_amount' => '10.00',
3655     ];
3656     $contribution = $this->callAPISuccess('contribution', 'create', $contribParams);
3657
3658     // Create line item
3659     $lineItemParams = [
3660       'contribution_id' => $contribution['id'],
3661       'entity_id' => $contribution['id'],
3662       'entity_table' => 'civicrm_contribution',
3663       'label' => 'My lineitem label',
3664       'qty' => 1,
3665       'unit_price' => "10.00",
3666       'line_total' => "10.00",
3667     ];
3668     $lineItem = $this->callAPISuccess('lineItem', 'create', $lineItemParams);
3669
3670     // Create email
3671     try {
3672       civicrm_api3('contribution', 'sendconfirmation', [
3673         'id' => $contribution['id'],
3674         'receipt_from_email' => 'api@civicrm.org',
3675       ]);
3676     }
3677     catch (Exception $e) {
3678       // Need to figure out how to stop this some other day
3679       // We don't care about the Payment Processor because this is Pay Later
3680       // The point of this test is to check we get the pay_later version of the mail
3681       if ($e->getMessage() != "Undefined variable: CRM16923AnUnreliableMethodHasBeenUserToDeterminePaymentProcessorFromContributionPage") {
3682         throw $e;
3683       }
3684     }
3685
3686     // Retrieve mail & check it has the pay_later_receipt info
3687     $mut->getMostRecentEmail('raw');
3688     $mut->checkMailLog([
3689       (string) $contribParams['total_amount'],
3690       $pageParams['pay_later_receipt'],
3691     ], [
3692       'Event',
3693     ]);
3694     $mut->stop();
3695   }
3696
3697   /**
3698    * Check credit card details in sent mail via API
3699    *
3700    * @param CiviMailUtils $mut
3701    * @param int $contributionID Contribution ID
3702    *
3703    * @throws \CRM_Core_Exception
3704    */
3705   public function checkCreditCardDetails($mut, $contributionID) {
3706     $this->callAPISuccess('contribution', 'create', $this->_params);
3707     $this->callAPISuccess('contribution', 'sendconfirmation', [
3708       'id' => $contributionID,
3709       'receipt_from_email' => 'api@civicrm.org',
3710       'payment_processor_id' => $this->paymentProcessorID,
3711     ]);
3712     $mut->checkMailLog([
3713       // billing header
3714       'Billing Name and Address',
3715       // billing name
3716       'anthony_anderson@civicrm.org',
3717     ], [
3718       'Event',
3719     ]);
3720   }
3721
3722   /**
3723    * Test sending a mail via the API.
3724    */
3725   public function testSendMailEvent() {
3726     $mut = new CiviMailUtils($this, TRUE);
3727     $contribution = $this->callAPISuccess('contribution', 'create', $this->_params);
3728     $event = $this->eventCreate([
3729       'is_email_confirm' => 1,
3730       'confirm_from_email' => 'test@civicrm.org',
3731     ]);
3732     $this->_eventID = $event['id'];
3733     $participantParams = [
3734       'contact_id' => $this->_individualId,
3735       'event_id' => $this->_eventID,
3736       'status_id' => 1,
3737       'role_id' => 1,
3738       // to ensure it matches later on
3739       'register_date' => '2007-07-21 00:00:00',
3740       'source' => 'Online Event Registration: API Testing',
3741
3742     ];
3743     $participant = $this->callAPISuccess('participant', 'create', $participantParams);
3744     $this->callAPISuccess('participant_payment', 'create', [
3745       'participant_id' => $participant['id'],
3746       'contribution_id' => $contribution['id'],
3747     ]);
3748     $this->callAPISuccess('contribution', 'sendconfirmation', [
3749       'id' => $contribution['id'],
3750       'receipt_from_email' => 'api@civicrm.org',
3751     ]);
3752
3753     $mut->checkMailLog([
3754       'Annual CiviCRM meet',
3755       'Event',
3756       'To: "Mr. Anthony Anderson II" <anthony_anderson@civicrm.org>',
3757     ], []);
3758     $mut->stop();
3759   }
3760
3761   /**
3762    * This function does a GET & compares the result against the $params.
3763    *
3764    * Use as a double check on Creates.
3765    *
3766    * @param array $params
3767    * @param int $id
3768    * @param bool $delete
3769    */
3770   public function contributionGetnCheck($params, $id, $delete = TRUE) {
3771
3772     $contribution = $this->callAPISuccess('Contribution', 'Get', [
3773       'id' => $id,
3774     ]);
3775
3776     if ($delete) {
3777       $this->callAPISuccess('contribution', 'delete', ['id' => $id]);
3778     }
3779     $this->assertAPISuccess($contribution, 0);
3780     $values = $contribution['values'][$contribution['id']];
3781     $params['receive_date'] = date('Y-m-d H:i:s', strtotime($params['receive_date']));
3782     // this is not returned in id format
3783     unset($params['payment_instrument_id']);
3784     $params['contribution_source'] = $params['source'];
3785     unset($params['source']);
3786     foreach ($params as $key => $value) {
3787       $this->assertEquals($value, $values[$key], $key . " value: $value doesn't match " . print_r($values, TRUE));
3788     }
3789   }
3790
3791   /**
3792    * Create a pending contribution & linked pending pledge record.
3793    */
3794   public function createPendingPledgeContribution() {
3795
3796     $pledgeID = $this->pledgeCreate(['contact_id' => $this->_individualId, 'installments' => 1, 'amount' => 500]);
3797     $this->_ids['pledge'] = $pledgeID;
3798     $contribution = $this->callAPISuccess('contribution', 'create', array_merge($this->_params, [
3799       'contribution_status_id' => 'Pending',
3800       'total_amount' => 500,
3801     ]));
3802     $paymentID = $this->callAPISuccessGetValue('PledgePayment', [
3803       'options' => ['limit' => 1],
3804       'return' => 'id',
3805     ]);
3806     $this->callAPISuccess('PledgePayment', 'create', [
3807       'id' => $paymentID,
3808       'contribution_id' =>
3809       $contribution['id'],
3810       'status_id' => 'Pending',
3811       'scheduled_amount' => 500,
3812     ]);
3813
3814     return $contribution['id'];
3815   }
3816
3817   /**
3818    * Create a pending contribution & linked pending participant record (along with an event).
3819    */
3820   public function createPendingParticipantContribution() {
3821     $this->_ids['event']['test'] = $this->eventCreate(['is_email_confirm' => 1, 'confirm_from_email' => 'test@civicrm.org'])['id'];
3822     $participantID = $this->participantCreate(['event_id' => $this->_ids['event']['test'], 'status_id' => 6, 'contact_id' => $this->_individualId]);
3823     $this->_ids['participant'] = $participantID;
3824     $params = array_merge($this->_params, ['contact_id' => $this->_individualId, 'contribution_status_id' => 2, 'financial_type_id' => 'Event Fee']);
3825     $contribution = $this->callAPISuccess('contribution', 'create', $params);
3826     $this->callAPISuccess('participant_payment', 'create', [
3827       'contribution_id' => $contribution['id'],
3828       'participant_id' => $participantID,
3829     ]);
3830     $this->callAPISuccess('line_item', 'get', [
3831       'entity_id' => $contribution['id'],
3832       'entity_table' => 'civicrm_contribution',
3833       'api.line_item.create' => [
3834         'entity_id' => $participantID,
3835         'entity_table' => 'civicrm_participant',
3836       ],
3837     ]);
3838     return $contribution['id'];
3839   }
3840
3841   /**
3842    * Get financial transaction amount.
3843    *
3844    * @param int $contId
3845    *
3846    * @return null|string
3847    */
3848   public function _getFinancialTrxnAmount($contId) {
3849     $query = "SELECT
3850      SUM( ft.total_amount ) AS total
3851      FROM civicrm_financial_trxn AS ft
3852      LEFT JOIN civicrm_entity_financial_trxn AS ceft ON ft.id = ceft.financial_trxn_id
3853      WHERE ceft.entity_table = 'civicrm_contribution'
3854      AND ceft.entity_id = {$contId}";
3855
3856     $result = CRM_Core_DAO::singleValueQuery($query);
3857     return $result;
3858   }
3859
3860   /**
3861    * @param int $contId
3862    *
3863    * @return null|string
3864    */
3865   public function _getFinancialItemAmount($contId) {
3866     $lineItem = key(CRM_Price_BAO_LineItem::getLineItems($contId, 'contribution'));
3867     $query = "SELECT
3868      SUM(amount)
3869      FROM civicrm_financial_item
3870      WHERE entity_table = 'civicrm_line_item'
3871      AND entity_id = {$lineItem}";
3872     $result = CRM_Core_DAO::singleValueQuery($query);
3873     return $result;
3874   }
3875
3876   /**
3877    * @param int $contId
3878    * @param $context
3879    */
3880   public function _checkFinancialItem($contId, $context) {
3881     if ($context != 'paylater') {
3882       $params = [
3883         'entity_id' => $contId,
3884         'entity_table' => 'civicrm_contribution',
3885       ];
3886       $trxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($params, TRUE));
3887       $entityParams = [
3888         'financial_trxn_id' => $trxn['financial_trxn_id'],
3889         'entity_table' => 'civicrm_financial_item',
3890       ];
3891       $entityTrxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($entityParams));
3892       $params = [
3893         'id' => $entityTrxn['entity_id'],
3894       ];
3895     }
3896     if ($context == 'paylater') {
3897       $lineItems = CRM_Price_BAO_LineItem::getLineItems($contId, 'contribution');
3898       foreach ($lineItems as $key => $item) {
3899         $params = [
3900           'entity_id' => $key,
3901           'entity_table' => 'civicrm_line_item',
3902         ];
3903         $compareParams = ['status_id' => 1];
3904         $this->assertDBCompareValues('CRM_Financial_DAO_FinancialItem', $params, $compareParams);
3905       }
3906     }
3907     elseif ($context == 'refund') {
3908       $compareParams = [
3909         'status_id' => 1,
3910         'financial_account_id' => 1,
3911         'amount' => -100,
3912       ];
3913     }
3914     elseif ($context == 'cancelPending') {
3915       $compareParams = [
3916         'status_id' => 3,
3917         'financial_account_id' => 1,
3918         'amount' => -100,
3919       ];
3920     }
3921     elseif ($context == 'changeFinancial') {
3922       $lineKey = key(CRM_Price_BAO_LineItem::getLineItems($contId, 'contribution'));
3923       $params = [
3924         'entity_id' => $lineKey,
3925         'amount' => -100,
3926       ];
3927       $compareParams = [
3928         'financial_account_id' => 1,
3929       ];
3930       $this->assertDBCompareValues('CRM_Financial_DAO_FinancialItem', $params, $compareParams);
3931       $params = [
3932         'financial_account_id' => 3,
3933         'entity_id' => $lineKey,
3934       ];
3935       $compareParams = [
3936         'amount' => 100,
3937       ];
3938     }
3939     if ($context != 'paylater') {
3940       $this->assertDBCompareValues('CRM_Financial_DAO_FinancialItem', $params, $compareParams);
3941     }
3942   }
3943
3944   /**
3945    * Check correct financial transaction entries were created for the change in payment instrument.
3946    *
3947    * @param int $contributionID
3948    * @param int $originalInstrumentID
3949    * @param int $newInstrumentID
3950    * @param int $amount
3951    */
3952   public function checkFinancialTrxnPaymentInstrumentChange($contributionID, $originalInstrumentID, $newInstrumentID, $amount = 100) {
3953
3954     $entityFinancialTrxns = $this->getFinancialTransactionsForContribution($contributionID);
3955
3956     $originalTrxnParams = [
3957       'to_financial_account_id' => CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($originalInstrumentID),
3958       'payment_instrument_id' => $originalInstrumentID,
3959       'amount' => $amount,
3960       'status_id' => 1,
3961     ];
3962
3963     $reversalTrxnParams = [
3964       'to_financial_account_id' => CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($originalInstrumentID),
3965       'payment_instrument_id' => $originalInstrumentID,
3966       'amount' => -$amount,
3967       'status_id' => 1,
3968     ];
3969
3970     $newTrxnParams = [
3971       'to_financial_account_id' => CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($newInstrumentID),
3972       'payment_instrument_id' => $newInstrumentID,
3973       'amount' => $amount,
3974       'status_id' => 1,
3975     ];
3976
3977     foreach ([$originalTrxnParams, $reversalTrxnParams, $newTrxnParams] as $index => $transaction) {
3978       $entityFinancialTrxn = $entityFinancialTrxns[$index];
3979       $this->assertEquals($entityFinancialTrxn['amount'], $transaction['amount']);
3980
3981       $financialTrxn = $this->callAPISuccessGetSingle('FinancialTrxn', [
3982         'id' => $entityFinancialTrxn['financial_trxn_id'],
3983       ]);
3984       $this->assertEquals($transaction['status_id'], $financialTrxn['status_id']);
3985       $this->assertEquals($transaction['amount'], $financialTrxn['total_amount']);
3986       $this->assertEquals($transaction['amount'], $financialTrxn['net_amount']);
3987       $this->assertEquals(0, $financialTrxn['fee_amount']);
3988       $this->assertEquals($transaction['payment_instrument_id'], $financialTrxn['payment_instrument_id']);
3989       $this->assertEquals($transaction['to_financial_account_id'], $financialTrxn['to_financial_account_id']);
3990
3991       // Generic checks.
3992       $this->assertEquals(1, $financialTrxn['is_payment']);
3993       $this->assertEquals('USD', $financialTrxn['currency']);
3994       $this->assertEquals(date('Y-m-d'), date('Y-m-d', strtotime($financialTrxn['trxn_date'])));
3995     }
3996   }
3997
3998   /**
3999    * Check financial transaction.
4000    *
4001    * @todo break this down into sensible functions - most calls to it only use a few lines out of the big if.
4002    *
4003    * @param array $contribution
4004    * @param string $context
4005    * @param int $instrumentId
4006    * @param array $extraParams
4007    */
4008   public function _checkFinancialTrxn($contribution, $context, $instrumentId = NULL, $extraParams = []) {
4009     $financialTrxns = $this->getFinancialTransactionsForContribution($contribution['id']);
4010     $trxn = array_pop($financialTrxns);
4011
4012     $params = [
4013       'id' => $trxn['financial_trxn_id'],
4014     ];
4015     if ($context == 'payLater') {
4016       $compareParams = [
4017         'status_id' => 1,
4018         'from_financial_account_id' => CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($contribution['financial_type_id'], 'Accounts Receivable Account is'),
4019       ];
4020     }
4021     elseif ($context == 'refund') {
4022       $compareParams = [
4023         'to_financial_account_id' => 6,
4024         'total_amount' => -100,
4025         'status_id' => 7,
4026         'trxn_date' => '2015-01-01 09:00:00',
4027         'trxn_id' => 'the refund',
4028       ];
4029     }
4030     elseif ($context == 'cancelPending') {
4031       $compareParams = [
4032         'to_financial_account_id' => 7,
4033         'total_amount' => -100,
4034         'status_id' => 3,
4035       ];
4036     }
4037     elseif ($context == 'changeFinancial' || $context == 'paymentInstrument') {
4038       // @todo checkFinancialTrxnPaymentInstrumentChange instead for paymentInstrument.
4039       // It does the same thing with greater readability.
4040       // @todo remove handling for
4041
4042       $entityParams = [
4043         'entity_id' => $contribution['id'],
4044         'entity_table' => 'civicrm_contribution',
4045         'amount' => -100,
4046       ];
4047       $trxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($entityParams));
4048       $trxnParams1 = [
4049         'id' => $trxn['financial_trxn_id'],
4050       ];
4051       if (empty($extraParams)) {
4052         $compareParams = [
4053           'total_amount' => -100,
4054           'status_id' => 1,
4055         ];
4056       }
4057       elseif ($context !== 'changeFinancial') {
4058         $compareParams = [
4059           'total_amount' => 100,
4060           'status_id' => 1,
4061         ];
4062       }
4063       if ($context == 'paymentInstrument') {
4064         $compareParams['to_financial_account_id'] = CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($instrumentId);
4065         $compareParams['payment_instrument_id'] = $instrumentId;
4066       }
4067       else {
4068         $compareParams['to_financial_account_id'] = 12;
4069       }
4070       $this->assertDBCompareValues('CRM_Financial_DAO_FinancialTrxn', $trxnParams1, array_merge($compareParams, $extraParams));
4071       $compareParams['total_amount'] = 100;
4072       // Reverse the extra params now that we will be checking the new positive transaction.
4073       if ($context === 'changeFinancial' && !empty($extraParams)) {
4074         foreach ($extraParams as $param => $value) {
4075           $extraParams[$param] = 0 - $value;
4076         }
4077       }
4078     }
4079
4080     $this->assertDBCompareValues('CRM_Financial_DAO_FinancialTrxn', $params, array_merge($compareParams, $extraParams));
4081   }
4082
4083   /**
4084    * @return mixed
4085    */
4086   public function _addPaymentInstrument() {
4087     $gId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_OptionGroup', 'payment_instrument', 'id', 'name');
4088     $optionParams = [
4089       'option_group_id' => $gId,
4090       'label' => 'Test Card',
4091       'name' => 'Test Card',
4092       'value' => '6',
4093       'weight' => '6',
4094       'is_active' => 1,
4095     ];
4096     $optionValue = $this->callAPISuccess('option_value', 'create', $optionParams);
4097     $relationTypeId = key(CRM_Core_PseudoConstant::accountOptionValues('account_relationship', NULL, " AND v.name LIKE 'Asset Account is' "));
4098     $financialParams = [
4099       'entity_table' => 'civicrm_option_value',
4100       'entity_id' => $optionValue['id'],
4101       'account_relationship' => $relationTypeId,
4102       'financial_account_id' => 7,
4103     ];
4104     CRM_Financial_BAO_FinancialTypeAccount::add($financialParams);
4105     $this->assertNotEmpty($optionValue['values'][$optionValue['id']]['value']);
4106     return $optionValue['values'][$optionValue['id']]['value'];
4107   }
4108
4109   public function _deletedAddedPaymentInstrument() {
4110     $result = $this->callAPISuccess('OptionValue', 'get', [
4111       'option_group_id' => 'payment_instrument',
4112       'name' => 'Test Card',
4113       'value' => '6',
4114       'is_active' => 1,
4115     ]);
4116     if ($id = CRM_Utils_Array::value('id', $result)) {
4117       $this->callAPISuccess('OptionValue', 'delete', ['id' => $id]);
4118     }
4119   }
4120
4121   /**
4122    * Set up the basic recurring contribution for tests.
4123    *
4124    * @param array $generalParams
4125    *   Parameters that can be merged into the recurring AND the contribution.
4126    *
4127    * @param array $recurParams
4128    *   Parameters to merge into the recur only.
4129    *
4130    * @return array|int
4131    * @throws \CRM_Core_Exception
4132    */
4133   protected function setUpRecurringContribution($generalParams = [], $recurParams = []) {
4134     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge([
4135       'contact_id' => $this->_individualId,
4136       'installments' => '12',
4137       'frequency_interval' => '1',
4138       'amount' => '100',
4139       'contribution_status_id' => 1,
4140       'start_date' => '2012-01-01 00:00:00',
4141       'currency' => 'USD',
4142       'frequency_unit' => 'month',
4143       'payment_processor_id' => $this->paymentProcessorID,
4144     ], $generalParams, $recurParams));
4145     $contributionParams = array_merge(
4146       $this->_params,
4147       [
4148         'contribution_recur_id' => $contributionRecur['id'],
4149         'contribution_status_id' => 'Pending',
4150       ], $generalParams);
4151     $contributionParams['api.Payment.create'] = ['total_amount' => $contributionParams['total_amount']];
4152     $originalContribution = $this->callAPISuccess('Order', 'create', $contributionParams);
4153     return $originalContribution;
4154   }
4155
4156   /**
4157    * Set up a basic auto-renew membership for tests.
4158    *
4159    * @param array $generalParams
4160    *   Parameters that can be merged into the recurring AND the contribution.
4161    *
4162    * @param array $recurParams
4163    *   Parameters to merge into the recur only.
4164    *
4165    * @return array|int
4166    * @throws \CRM_Core_Exception
4167    */
4168   protected function setUpAutoRenewMembership($generalParams = [], $recurParams = []) {
4169     $newContact = $this->callAPISuccess('Contact', 'create', [
4170       'contact_type' => 'Individual',
4171       'sort_name' => 'McTesterson, Testy',
4172       'display_name' => 'Testy McTesterson',
4173       'preferred_language' => 'en_US',
4174       'preferred_mail_format' => 'Both',
4175       'first_name' => 'Testy',
4176       'last_name' => 'McTesterson',
4177       'contact_is_deleted' => '0',
4178       'email_id' => '4',
4179       'email' => 'tmctesterson@example.com',
4180       'on_hold' => '0',
4181     ]);
4182     $membershipType = $this->callAPISuccess('MembershipType', 'create', [
4183       'domain_id' => 'Default Domain Name',
4184       'member_of_contact_id' => 1,
4185       'financial_type_id' => 'Member Dues',
4186       'duration_unit' => 'month',
4187       'duration_interval' => 1,
4188       'period_type' => 'rolling',
4189       'name' => 'Standard Member',
4190       'minimum_fee' => 100,
4191     ]);
4192     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge([
4193       'contact_id' => $newContact['id'],
4194       'installments' => '12',
4195       'frequency_interval' => '1',
4196       'amount' => '100',
4197       'contribution_status_id' => 1,
4198       'start_date' => '2012-01-01 00:00:00',
4199       'currency' => 'USD',
4200       'frequency_unit' => 'month',
4201       'payment_processor_id' => $this->paymentProcessorID,
4202     ], $generalParams, $recurParams));
4203
4204     $membership = $this->callAPISuccess('membership', 'create', [
4205       'contact_id' => $newContact['id'],
4206       'contribution_recur_id' => $contributionRecur['id'],
4207       'financial_type_id' => "Member Dues",
4208       'membership_type_id' => $membershipType['id'],
4209       'num_terms' => 1,
4210       'skipLineItem' => TRUE,
4211     ]);
4212
4213     CRM_Price_BAO_LineItem::getLineItemArray($this->_params, NULL, 'membership', $membershipType['id']);
4214     $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
4215       $this->_params,
4216       [
4217         'contact_id' => $newContact['id'],
4218         'contribution_recur_id' => $contributionRecur['id'],
4219         'financial_type_id' => "Member Dues",
4220         'contribution_status_id' => 1,
4221         'invoice_id' => uniqid(),
4222       ], $generalParams)
4223     );
4224     $lineItem = $this->callAPISuccess('LineItem', 'getsingle', []);
4225     $this->assertEquals('civicrm_membership', $lineItem['entity_table']);
4226     $membership = $this->callAPISuccess('Membership', 'getsingle', ['id' => $lineItem['entity_id']]);
4227     $this->callAPISuccess('LineItem', 'getsingle', []);
4228     $this->callAPISuccessGetCount('MembershipPayment', ['membership_id' => $membership['id']], 1);
4229
4230     return [$originalContribution, $membership];
4231   }
4232
4233   /**
4234    * Set up a repeat transaction.
4235    *
4236    * @param array $recurParams
4237    * @param mixed $flag
4238    * @param array $contributionParams
4239    * @return array
4240    */
4241   protected function setUpRepeatTransaction($recurParams = [], $flag, $contributionParams = []) {
4242     $paymentProcessorID = $this->paymentProcessorCreate();
4243     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge([
4244       'contact_id' => $this->_individualId,
4245       'installments' => '12',
4246       'frequency_interval' => '1',
4247       'amount' => '500',
4248       'contribution_status_id' => 1,
4249       'start_date' => '2012-01-01 00:00:00',
4250       'currency' => 'USD',
4251       'frequency_unit' => 'month',
4252       'payment_processor_id' => $paymentProcessorID,
4253     ], $recurParams));
4254
4255     $originalContribution = '';
4256     if ($flag == 'multiple') {
4257       // CRM-19309 create a contribution + also add in line_items (plural):
4258       $params = array_merge($this->_params, $contributionParams);
4259       $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
4260           $params,
4261           [
4262             'contribution_recur_id' => $contributionRecur['id'],
4263             'skipLineItem' => 1,
4264             'api.line_item.create' => [
4265               [
4266                 'price_field_id' => 1,
4267                 'qty' => 2,
4268                 'line_total' => '20',
4269                 'unit_price' => '10',
4270                 'financial_type_id' => 1,
4271               ],
4272               [
4273                 'price_field_id' => 1,
4274                 'qty' => 1,
4275                 'line_total' => '80',
4276                 'unit_price' => '80',
4277                 'financial_type_id' => 2,
4278               ],
4279             ],
4280           ]
4281         )
4282       );
4283     }
4284     elseif ($flag == 'single') {
4285       $params = array_merge($this->_params, ['contribution_recur_id' => $contributionRecur['id']]);
4286       $params = array_merge($params, $contributionParams);
4287       $originalContribution = $this->callAPISuccess('contribution', 'create', $params);
4288     }
4289     $originalContribution['contribution_recur_id'] = $contributionRecur['id'];
4290     $originalContribution['payment_processor_id'] = $paymentProcessorID;
4291     return $originalContribution;
4292   }
4293
4294   /**
4295    * Common set up routine.
4296    *
4297    * @return array
4298    */
4299   protected function setUpForCompleteTransaction() {
4300     $this->mut = new CiviMailUtils($this, TRUE);
4301     $this->createLoggedInUser();
4302     $params = array_merge($this->_params, ['contribution_status_id' => 2, 'receipt_date' => 'now']);
4303     $contribution = $this->callAPISuccess('contribution', 'create', $params);
4304     return $contribution;
4305   }
4306
4307   /**
4308    * Test repeat contribution uses the Payment Processor' payment_instrument setting.
4309    *
4310    * @throws \CRM_Core_Exception
4311    */
4312   public function testRepeatTransactionWithNonCreditCardDefault() {
4313     $contributionRecur = $this->callAPISuccess('ContributionRecur', 'create', [
4314       'contact_id' => $this->_individualId,
4315       'installments' => '12',
4316       'frequency_interval' => '1',
4317       'amount' => '100',
4318       'contribution_status_id' => 1,
4319       'start_date' => '2012-01-01 00:00:00',
4320       'currency' => 'USD',
4321       'frequency_unit' => 'month',
4322       'payment_processor_id' => $this->paymentProcessorID,
4323     ]);
4324     $contribution1 = $this->callAPISuccess('contribution', 'create', array_merge(
4325         $this->_params,
4326         ['contribution_recur_id' => $contributionRecur['id'], 'payment_instrument_id' => 2])
4327     );
4328     $contribution2 = $this->callAPISuccess('contribution', 'repeattransaction', [
4329       'contribution_status_id' => 'Completed',
4330       'trxn_id' => 'blah',
4331       'original_contribution_id' => $contribution1,
4332     ]);
4333     $this->assertEquals('Debit Card', CRM_Contribute_PseudoConstant::getLabel('CRM_Contribute_BAO_Contribution', 'payment_instrument_id', $contribution2['values'][$contribution2['id']]['payment_instrument_id']));
4334   }
4335
4336   /**
4337    * CRM-20008 Tests repeattransaction creates pending membership.
4338    */
4339   public function testRepeatTransactionMembershipCreatePendingContribution() {
4340     list($originalContribution, $membership) = $this->setUpAutoRenewMembership();
4341     $this->callAPISuccess('membership', 'create', [
4342       'id' => $membership['id'],
4343       'end_date' => 'yesterday',
4344       'status_id' => 'Expired',
4345     ]);
4346     $repeatedContribution = $this->callAPISuccess('contribution', 'repeattransaction', [
4347       'contribution_recur_id' => $originalContribution['values'][1]['contribution_recur_id'],
4348       'contribution_status_id' => 'Pending',
4349       'trxn_id' => uniqid(),
4350     ]);
4351     $membershipStatusId = $this->callAPISuccess('membership', 'getvalue', [
4352       'id' => $membership['id'],
4353       'return' => 'status_id',
4354     ]);
4355
4356     // Let's see if the membership payments got created while we're at it.
4357     $membershipPayments = $this->callAPISuccess('MembershipPayment', 'get', [
4358       'membership_id' => $membership['id'],
4359     ]);
4360     $this->assertEquals(2, $membershipPayments['count']);
4361
4362     $this->assertEquals('Expired', CRM_Core_PseudoConstant::getLabel('CRM_Member_BAO_Membership', 'status_id', $membershipStatusId));
4363     $this->callAPISuccess('Contribution', 'completetransaction', ['id' => $repeatedContribution['id']]);
4364     $membership = $this->callAPISuccessGetSingle('membership', [
4365       'id' => $membership['id'],
4366       'return' => 'status_id, end_date',
4367     ]);
4368     $this->assertEquals('New', CRM_Core_PseudoConstant::getName('CRM_Member_BAO_Membership', 'status_id', $membership['status_id']));
4369     $this->assertEquals(date('Y-m-d', strtotime('yesterday + 1 month')), $membership['end_date']);
4370   }
4371
4372   /**
4373    * Test sending a mail via the API.
4374    *
4375    * @throws \CRM_Core_Exception
4376    */
4377   public function testSendMailWithAPISetFromDetails() {
4378     $mut = new CiviMailUtils($this, TRUE);
4379     $contribution = $this->callAPISuccess('contribution', 'create', $this->_params);
4380     $this->callAPISuccess('contribution', 'sendconfirmation', [
4381       'id' => $contribution['id'],
4382       'receipt_from_email' => 'api@civicrm.org',
4383       'receipt_from_name' => 'CiviCRM LLC',
4384     ]);
4385     $mut->checkMailLog([
4386       'From: CiviCRM LLC <api@civicrm.org>',
4387       'Contribution Information',
4388     ], [
4389       'Event',
4390     ]);
4391     $mut->stop();
4392   }
4393
4394   /**
4395    * Test sending a mail via the API.
4396    */
4397   public function testSendMailWithNoFromSetFallToDomain() {
4398     $this->createLoggedInUser();
4399     $mut = new CiviMailUtils($this, TRUE);
4400     $contribution = $this->callAPISuccess('contribution', 'create', $this->_params);
4401     $this->callAPISuccess('contribution', 'sendconfirmation', [
4402       'id' => $contribution['id'],
4403     ]);
4404     $domain = $this->callAPISuccess('domain', 'getsingle', ['id' => 1]);
4405     $mut->checkMailLog([
4406       'From: ' . $domain['from_name'] . ' <' . $domain['from_email'] . '>',
4407       'Contribution Information',
4408     ], [
4409       'Event',
4410     ]);
4411     $mut->stop();
4412   }
4413
4414   /**
4415    * Test sending a mail via the API.
4416    */
4417   public function testSendMailWithRepeatTransactionAPIFalltoDomain() {
4418     $this->createLoggedInUser();
4419     $mut = new CiviMailUtils($this, TRUE);
4420     $contribution = $this->setUpRepeatTransaction([], 'single');
4421     $this->callAPISuccess('contribution', 'repeattransaction', [
4422       'contribution_status_id' => 'Completed',
4423       'trxn_id' => uniqid(),
4424       'original_contribution_id' => $contribution,
4425     ]);
4426     $domain = $this->callAPISuccess('domain', 'getsingle', ['id' => 1]);
4427     $mut->checkMailLog([
4428       'From: ' . $domain['from_name'] . ' <' . $domain['from_email'] . '>',
4429       'Contribution Information',
4430     ], [
4431       'Event',
4432     ]
4433     );
4434     $mut->stop();
4435   }
4436
4437   /**
4438    * Test sending a mail via the API.
4439    */
4440   public function testSendMailWithRepeatTransactionAPIFalltoContributionPage() {
4441     $mut = new CiviMailUtils($this, TRUE);
4442     $contributionPage = $this->contributionPageCreate(['receipt_from_name' => 'CiviCRM LLC', 'receipt_from_email' => 'contributionpage@civicrm.org', 'is_email_receipt' => 1]);
4443     $paymentProcessorID = $this->paymentProcessorCreate();
4444     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', [
4445       'contact_id' => $this->_individualId,
4446       'installments' => '12',
4447       'frequency_interval' => '1',
4448       'amount' => '500',
4449       'contribution_status_id' => 1,
4450       'start_date' => '2012-01-01 00:00:00',
4451       'currency' => 'USD',
4452       'frequency_unit' => 'month',
4453       'payment_processor_id' => $paymentProcessorID,
4454     ]);
4455     $originalContribution = $this->callAPISuccess('contribution', 'create', array_merge(
4456       $this->_params,
4457       [
4458         'contribution_recur_id' => $contributionRecur['id'],
4459         'contribution_page_id' => $contributionPage['id'],
4460       ])
4461     );
4462     $this->callAPISuccess('contribution', 'repeattransaction', [
4463       'contribution_status_id' => 'Completed',
4464       'trxn_id' => uniqid(),
4465       'original_contribution_id' => $originalContribution,
4466     ]
4467     );
4468     $mut->checkMailLog([
4469       'From: CiviCRM LLC <contributionpage@civicrm.org>',
4470       'Contribution Information',
4471     ], [
4472       'Event',
4473     ]);
4474     $mut->stop();
4475   }
4476
4477   /**
4478    * Test sending a mail via the API.
4479    */
4480   public function testSendMailWithRepeatTransactionAPIFalltoSystemFromNoDefaultFrom() {
4481     $mut = new CiviMailUtils($this, TRUE);
4482     $originalContribution = $contribution = $this->setUpRepeatTransaction([], 'single');
4483     $fromEmail = $this->CallAPISuccess('optionValue', 'get', ['is_default' => 1, 'option_group_id' => 'from_email_address', 'sequential' => 1]);
4484     foreach ($fromEmail['values'] as $from) {
4485       $this->callAPISuccess('optionValue', 'create', ['is_default' => 0, 'id' => $from['id']]);
4486     }
4487     $domain = $this->callAPISuccess('domain', 'getsingle', ['id' => CRM_Core_Config::domainID()]);
4488     $this->callAPISuccess('contribution', 'repeattransaction', [
4489       'contribution_status_id' => 'Completed',
4490       'trxn_id' => uniqid(),
4491       'original_contribution_id' => $originalContribution,
4492     ]);
4493     $mut->checkMailLog([
4494       'From: ' . $domain['name'] . ' <' . $domain['domain_email'] . '>',
4495       'Contribution Information',
4496     ], [
4497       'Event',
4498     ]);
4499     $mut->stop();
4500   }
4501
4502   /**
4503    * Create a Contribution Page with is_email_receipt = TRUE.
4504    *
4505    * @param array $params
4506    *   Params to overwrite with.
4507    *
4508    * @return array|int
4509    */
4510   protected function createReceiptableContributionPage($params = []) {
4511     $contributionPage = $this->callAPISuccess('ContributionPage', 'create', array_merge([
4512       'receipt_from_name' => 'Mickey Mouse',
4513       'receipt_from_email' => 'mickey@mouse.com',
4514       'title' => "Test Contribution Page",
4515       'financial_type_id' => 1,
4516       'currency' => 'CAD',
4517       'is_monetary' => TRUE,
4518       'is_email_receipt' => TRUE,
4519     ], $params));
4520     return $contributionPage;
4521   }
4522
4523   /**
4524    * function to test card_type and pan truncation.
4525    */
4526   public function testCardTypeAndPanTruncation() {
4527     $creditCardTypeIDs = array_flip(CRM_Financial_DAO_FinancialTrxn::buildOptions('card_type_id'));
4528     $contactId = $this->individualCreate();
4529     $params = [
4530       'contact_id' => $contactId,
4531       'receive_date' => '2016-01-20',
4532       'total_amount' => 100,
4533       'financial_type_id' => 1,
4534       'payment_instrument' => 'Credit Card',
4535       'card_type_id' => $creditCardTypeIDs['Visa'],
4536       'pan_truncation' => 4567,
4537     ];
4538     $contribution = $this->callAPISuccess('contribution', 'create', $params);
4539     $lastFinancialTrxnId = CRM_Core_BAO_FinancialTrxn::getFinancialTrxnId($contribution['id'], 'DESC');
4540     $financialTrxn = $this->callAPISuccessGetSingle(
4541       'FinancialTrxn',
4542       [
4543         'id' => $lastFinancialTrxnId['financialTrxnId'],
4544         'return' => ['card_type_id', 'pan_truncation'],
4545       ]
4546     );
4547     $this->assertEquals(CRM_Utils_Array::value('card_type_id', $financialTrxn), $creditCardTypeIDs['Visa']);
4548     $this->assertEquals(CRM_Utils_Array::value('pan_truncation', $financialTrxn), 4567);
4549     $params = [
4550       'id' => $contribution['id'],
4551       'pan_truncation' => 2345,
4552       'card_type_id' => $creditCardTypeIDs['Amex'],
4553     ];
4554     $contribution = $this->callAPISuccess('contribution', 'create', $params);
4555     $financialTrxn = $this->callAPISuccessGetSingle(
4556       'FinancialTrxn',
4557       [
4558         'id' => $lastFinancialTrxnId['financialTrxnId'],
4559         'return' => ['card_type_id', 'pan_truncation'],
4560       ]
4561     );
4562     $this->assertEquals(CRM_Utils_Array::value('card_type_id', $financialTrxn), $creditCardTypeIDs['Amex']);
4563     $this->assertEquals(CRM_Utils_Array::value('pan_truncation', $financialTrxn), 2345);
4564   }
4565
4566   /**
4567    * Test repeat contribution uses non default currency
4568    * @see https://issues.civicrm.org/jira/projects/CRM/issues/CRM-20678
4569    */
4570   public function testRepeatTransactionWithDifferenceCurrency() {
4571     $originalContribution = $this->setUpRepeatTransaction(['currency' => 'AUD'], 'single', ['currency' => 'AUD']);
4572     $contribution = $this->callAPISuccess('contribution', 'repeattransaction', [
4573       'original_contribution_id' => $originalContribution['id'],
4574       'contribution_status_id' => 'Completed',
4575       'trxn_id' => uniqid(),
4576     ]);
4577     $this->assertEquals('AUD', $contribution['values'][$contribution['id']]['currency']);
4578   }
4579
4580   /**
4581    * Get the financial items for the contribution.
4582    *
4583    * @param int $contributionID
4584    *
4585    * @return array
4586    *   Array of associated financial items.
4587    */
4588   protected function getFinancialTransactionsForContribution($contributionID) {
4589     $trxnParams = [
4590       'entity_id' => $contributionID,
4591       'entity_table' => 'civicrm_contribution',
4592     ];
4593     // @todo the following function has naming errors & has a weird signature & appears to
4594     // only be called from test classes. Move into test suite & maybe just use api
4595     // from this function.
4596     return array_merge(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($trxnParams));
4597   }
4598
4599   /**
4600    * Test getunique api call for Contribution entity
4601    */
4602   public function testContributionGetUnique() {
4603     $result = $this->callAPIAndDocument($this->entity, 'getunique', [], __FUNCTION__, __FILE__);
4604     $this->assertEquals(2, $result['count']);
4605     $this->assertEquals(['trxn_id'], $result['values']['UI_contrib_trxn_id']);
4606     $this->assertEquals(['invoice_id'], $result['values']['UI_contrib_invoice_id']);
4607   }
4608
4609   /**
4610    * Test Repeat Transaction Contribution with Tax amount.
4611    * https://lab.civicrm.org/dev/core/issues/806
4612    */
4613   public function testRepeatContributionWithTaxAmount() {
4614     $this->enableTaxAndInvoicing();
4615     $financialType = $this->callAPISuccess('financial_type', 'create', [
4616       'name' => 'Test taxable financial Type',
4617       'is_reserved' => 0,
4618       'is_active' => 1,
4619     ]);
4620     $this->relationForFinancialTypeWithFinancialAccount($financialType['id']);
4621     $contribution = $this->setUpRepeatTransaction(
4622       [],
4623       'single',
4624       [
4625         'financial_type_id' => $financialType['id'],
4626       ]
4627     );
4628     $this->callAPISuccess('contribution', 'repeattransaction', [
4629       'original_contribution_id' => $contribution['id'],
4630       'contribution_status_id' => 'Completed',
4631       'trxn_id' => uniqid(),
4632     ]);
4633     $payments = $this->callAPISuccess('Contribution', 'get', ['sequential' => 1])['values'];
4634     //Assert if first payment and repeated payment has the same contribution amount.
4635     $this->assertEquals($payments[0]['total_amount'], $payments[1]['total_amount']);
4636     $this->callAPISuccessGetCount('Contribution', [], 2);
4637
4638     //Assert line item records.
4639     $lineItems = $this->callAPISuccess('LineItem', 'get', ['sequential' => 1])['values'];
4640     foreach ($lineItems as $lineItem) {
4641       $this->assertEquals($lineItem['unit_price'], $this->_params['total_amount']);
4642       $this->assertEquals($lineItem['line_total'], $this->_params['total_amount']);
4643     }
4644     $this->callAPISuccessGetCount('Contribution', [], 2);
4645   }
4646
4647   public function testGetCurrencyOptions() {
4648     $result = $this->callAPISuccess('Contribution', 'getoptions', [
4649       'field' => 'currency',
4650     ]);
4651     $this->assertEquals('US Dollar', $result['values']['USD']);
4652     $this->assertNotContains('$', $result['values']);
4653     $result = $this->callAPISuccess('Contribution', 'getoptions', [
4654       'field' => 'currency',
4655       'context' => "abbreviate",
4656     ]);
4657     $this->assertEquals('$', $result['values']['USD']);
4658     $this->assertNotContains('US Dollar', $result['values']);
4659   }
4660
4661   /**
4662    * @throws \API_Exception
4663    * @throws \CRM_Core_Exception
4664    * @throws \Civi\API\Exception\UnauthorizedException
4665    */
4666   public function testSetCustomDataInCreateAndHook() {
4667     $this->createCustomGroupWithFieldOfType([], 'int');
4668     $this->ids['CustomField']['text'] = (int) $this->createTextCustomField(['custom_group_id' => $this->ids['CustomGroup']['Custom Group']])['id'];
4669     $this->hookClass->setHook('civicrm_post', [
4670       $this,
4671       'civicrmPostContributionCustom',
4672     ]);
4673     $params = $this->_params;
4674     $params['custom_' . $this->ids['CustomField']['text']] = 'Some Text';
4675     $contribution = $this->callAPISuccess('Contribution', 'create', $params);
4676     $getContribution = $this->callAPISuccess('Contribution', 'get', [
4677       'id' => $contribution['id'],
4678       'return' => ['id', 'custom_' . $this->ids['CustomField']['text'], 'custom_' . $this->ids['CustomField']['int']],
4679     ]);
4680     $this->assertEquals(5, $getContribution['values'][$contribution['id']][$this->getCustomFieldName('int')]);
4681     $this->assertEquals('Some Text', $getContribution['values'][$contribution['id']]['custom_' . $this->ids['CustomField']['text']]);
4682     $this->callAPISuccess('CustomField', 'delete', ['id' => $this->ids['CustomField']['text']]);
4683     $this->callAPISuccess('CustomField', 'delete', ['id' => $this->ids['CustomField']['int']]);
4684     $this->callAPISuccess('CustomGroup', 'delete', ['id' => $this->ids['CustomGroup']['Custom Group']]);
4685   }
4686
4687   /**
4688    * Implement post hook.
4689    *
4690    * @param string $op
4691    * @param string $objectName
4692    * @param int $objectId
4693    * @param \CRM_Core_DAO $objectRef
4694    *
4695    * @throws \CRM_Core_Exception
4696    */
4697   public function civicrmPostContributionCustom($op, $objectName, $objectId, &$objectRef) {
4698     if ($objectName === 'Contribution' && $op === 'create') {
4699       $this->callAPISuccess('Contribution', 'create', [
4700         'id' => $objectId,
4701         'custom_' . $this->ids['CustomField']['int'] => 5,
4702       ]);
4703     }
4704   }
4705
4706   /**
4707    * Test that passing in label for an option value linked to a custom field works
4708    * @see dev/core#1816
4709    */
4710   public function testCustomValueOptionLabelTest() {
4711     $this->createCustomGroupWithFieldOfType([], 'radio');
4712     $params = $this->_params;
4713     $params['custom_' . $this->ids['CustomField']['radio']] = 'Red Testing';
4714     $contribution = $this->callAPISuccess('Contribution', 'Create', $params);
4715   }
4716
4717   /**
4718    * Test repeatTransaction with installments and next_sched_contribution_date
4719    *
4720    * @dataProvider getRepeatTransactionNextSchedData
4721    *
4722    * @param array $dataSet
4723    *
4724    * @throws \Exception
4725    */
4726   public function testRepeatTransactionUpdateNextSchedContributionDate($dataSet) {
4727     $paymentProcessorID = $this->paymentProcessorCreate();
4728     // Create the contribution before the recur so it doesn't trigger the update of next_sched_contribution_date
4729     $contribution = $this->callAPISuccess('contribution', 'create', array_merge(
4730         $this->_params,
4731         [
4732           'contribution_status_id' => 'Completed',
4733           'receive_date' => $dataSet['repeat'][0]['receive_date'],
4734         ])
4735     );
4736     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge([
4737       'contact_id' => $this->_individualId,
4738       'frequency_interval' => '1',
4739       'amount' => '500',
4740       'contribution_status_id' => 'Pending',
4741       'start_date' => '2012-01-01 00:00:00',
4742       'currency' => 'USD',
4743       'frequency_unit' => 'month',
4744       'payment_processor_id' => $paymentProcessorID,
4745     ], $dataSet['recur']));
4746     // Link the existing contribution to the recur *after* creating the recur.
4747     // If we just created the contribution now the next_sched_contribution_date would be automatically set
4748     //   and we want to test the case when it is empty.
4749     $this->callAPISuccess('contribution', 'create', [
4750       'id' => $contribution['id'],
4751       'contribution_recur_id' => $contributionRecur['id'],
4752     ]);
4753
4754     $contributionRecur = $this->callAPISuccessGetSingle('ContributionRecur', [
4755       'id' => $contributionRecur['id'],
4756       'return' => ['next_sched_contribution_date', 'contribution_status_id'],
4757     ]);
4758     // Check that next_sched_contribution_date is empty
4759     $this->assertEquals('', $contributionRecur['next_sched_contribution_date'] ?? '');
4760
4761     $this->callAPISuccess('Contribution', 'repeattransaction', [
4762       'contribution_status_id' => 'Completed',
4763       'contribution_recur_id' => $contributionRecur['id'],
4764       'receive_date' => $dataSet['repeat'][0]['receive_date'],
4765     ]);
4766     $contributionRecur = $this->callAPISuccessGetSingle('ContributionRecur', [
4767       'id' => $contributionRecur['id'],
4768       'return' => ['next_sched_contribution_date', 'contribution_status_id'],
4769     ]);
4770     // Check that recur has status "In Progress"
4771     $this->assertEquals(
4772       (string) CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_ContributionRecur', 'contribution_status_id', $dataSet['repeat'][0]['expectedRecurStatus']),
4773       $contributionRecur['contribution_status_id']
4774     );
4775     // Check that next_sched_contribution_date has been set to 1 period after the contribution receive date (ie. 1 month)
4776     $this->assertEquals($dataSet['repeat'][0]['expectedNextSched'], $contributionRecur['next_sched_contribution_date']);
4777
4778     // Now call Contribution.repeattransaction again and check that the next_sched_contribution_date has moved forward by 1 period again
4779     $this->callAPISuccess('Contribution', 'repeattransaction', [
4780       'contribution_status_id' => 'Completed',
4781       'contribution_recur_id' => $contributionRecur['id'],
4782       'receive_date' => $dataSet['repeat'][1]['receive_date'],
4783     ]);
4784     $contributionRecur = $this->callAPISuccessGetSingle('ContributionRecur', [
4785       'id' => $contributionRecur['id'],
4786       'return' => ['next_sched_contribution_date', 'contribution_status_id'],
4787     ]);
4788     // Check that recur has status "In Progress" or "Completed" depending on whether number of installments has been reached
4789     $this->assertEquals(
4790       (string) CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_ContributionRecur', 'contribution_status_id', $dataSet['repeat'][1]['expectedRecurStatus']),
4791       $contributionRecur['contribution_status_id']
4792     );
4793     // Check that next_sched_contribution_date has been set to 1 period after the contribution receive date (ie. 1 month)
4794     $this->assertEquals($dataSet['repeat'][1]['expectedNextSched'], $contributionRecur['next_sched_contribution_date'] ?? '');
4795   }
4796
4797   /**
4798    * Get dates for testing.
4799    *
4800    * @return array
4801    */
4802   public function getRepeatTransactionNextSchedData() {
4803     // Both these tests handle/test the case that next_sched_contribution_date is empty when Contribution.repeattransaction
4804     //   is called for the first time. Historically setting it was inconsistent but on new updates it should always be set.
4805     /*
4806      * This tests that calling Contribution.repeattransaction with installments does the following:
4807      * - For the first call to repeattransaction the recur status is In Progress and next_sched_contribution_date is updated
4808      *   to match next expected receive_date.
4809      * - Once the 3rd contribution is created contributionRecur status = completed and next_sched_contribution_date = ''.
4810      */
4811     $result['receive_date_includes_time_with_installments']['2012-01-01-1-month'] = [
4812       'recur' => [
4813         'start_date' => '2012-01-01',
4814         'frequency_interval' => 1,
4815         'installments' => '3',
4816         'frequency_unit' => 'month',
4817       ],
4818       'repeat' => [
4819         [
4820           'receive_date' => '2012-02-29 16:00:00',
4821           'expectedNextSched' => '2012-03-29 00:00:00',
4822           'expectedRecurStatus' => 'In Progress',
4823         ],
4824         [
4825           'receive_date' => '2012-03-29 16:00:00',
4826           'expectedNextSched' => '',
4827           'expectedRecurStatus' => 'Completed',
4828         ],
4829       ],
4830     ];
4831     /*
4832      * This tests that calling Contribution.repeattransaction with no installments does the following:
4833      * - For the each call to repeattransaction the recur status is In Progress and next_sched_contribution_date is updated
4834      *   to match next expected receive_date.
4835      */
4836     $result['receive_date_includes_time_no_installments']['2012-01-01-1-month'] = [
4837       'recur' => [
4838         'start_date' => '2012-01-01',
4839         'frequency_interval' => 1,
4840         'frequency_unit' => 'month',
4841       ],
4842       'repeat' => [
4843         [
4844           'receive_date' => '2012-02-29 16:00:00',
4845           'expectedNextSched' => '2012-03-29 00:00:00',
4846           'expectedRecurStatus' => 'In Progress',
4847         ],
4848         [
4849           'receive_date' => '2012-03-29 16:00:00',
4850           'expectedNextSched' => '2012-04-29 00:00:00',
4851           'expectedRecurStatus' => 'In Progress',
4852         ],
4853       ],
4854     ];
4855     return $result;
4856   }
4857
4858   /**
4859    * Make sure that recording a payment doesn't alter the receive_date of a
4860    * pending contribution.
4861    */
4862   public function testPaymentDontChangeReceiveDate() {
4863     $params = [
4864       'contact_id' => $this->_individualId,
4865       'total_amount' => 100,
4866       'receive_date' => '2020-02-02',
4867       'contribution_status_id' => 'Pending',
4868     ];
4869     $contributionID = $this->contributionCreate($params);
4870     $paymentParams = [
4871       'contribution_id' => $contributionID,
4872       'total_amount' => 100,
4873       'trxn_date' => '2020-03-04',
4874     ];
4875     $this->callAPISuccess('payment', 'create', $paymentParams);
4876
4877     //check if contribution status is set to "Completed".
4878     $contribution = $this->callAPISuccess('Contribution', 'getSingle', [
4879       'id' => $contributionID,
4880     ]);
4881     $this->assertEquals('2020-02-02 00:00:00', $contribution['receive_date']);
4882   }
4883
4884 }