CRM/Contribute/Import/Parser/Contribution.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 5                                                  |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2019                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2019
  32  */
  33
  34 /**
  35  * Class to parse contribution csv files.
  36  */
  37 class CRM_Contribute_Import_Parser_Contribution extends CRM_Contribute_Import_Parser {
  38
  39   protected $_mapperKeys;
  40
  41   private $_contactIdIndex;
  42   private $_totalAmountIndex;
  43   private $_contributionTypeIndex;
  44
  45   protected $_mapperSoftCredit;
  46   //protected $_mapperPhoneType;
  47
  48   /**
  49    * Array of successfully imported contribution id's
  50    *
  51    * @var array
  52    */
  53   protected $_newContributions;
  54
  55   /**
  56    * Class constructor.
  57    *
  58    * @param $mapperKeys
  59    * @param array $mapperSoftCredit
  60    * @param null $mapperPhoneType
  61    * @param array $mapperSoftCreditType
  62    */
  63   public function __construct(&$mapperKeys, $mapperSoftCredit = [], $mapperPhoneType = NULL, $mapperSoftCreditType = []) {
  64     parent::__construct();
  65     $this->_mapperKeys = &$mapperKeys;
  66     $this->_mapperSoftCredit = &$mapperSoftCredit;
  67     $this->_mapperSoftCreditType = &$mapperSoftCreditType;
  68   }
  69
  70   /**
  71    * The initializer code, called before the processing
  72    */
  73   public function init() {
  74     $fields = CRM_Contribute_BAO_Contribution::importableFields($this->_contactType, FALSE);
  75
  76     $fields = array_merge($fields,
  77       [
  78         'soft_credit' => [
  79           'title' => ts('Soft Credit'),
  80           'softCredit' => TRUE,
  81           'headerPattern' => '/Soft Credit/i',
  82         ],
  83       ]
  84     );
  85
  86     // add pledge fields only if its is enabled
  87     if (CRM_Core_Permission::access('CiviPledge')) {
  88       $pledgeFields = [
  89         'pledge_payment' => [
  90           'title' => ts('Pledge Payment'),
  91           'headerPattern' => '/Pledge Payment/i',
  92         ],
  93         'pledge_id' => [
  94           'title' => ts('Pledge ID'),
  95           'headerPattern' => '/Pledge ID/i',
  96         ],
  97       ];
  98
  99       $fields = array_merge($fields, $pledgeFields);
 100     }
 101     foreach ($fields as $name => $field) {
 102       $field['type'] = CRM_Utils_Array::value('type', $field, CRM_Utils_Type::T_INT);
 103       $field['dataPattern'] = CRM_Utils_Array::value('dataPattern', $field, '//');
 104       $field['headerPattern'] = CRM_Utils_Array::value('headerPattern', $field, '//');
 105       $this->addField($name, $field['title'], $field['type'], $field['headerPattern'], $field['dataPattern']);
 106     }
 107
 108     $this->_newContributions = [];
 109
 110     $this->setActiveFields($this->_mapperKeys);
 111     $this->setActiveFieldSoftCredit($this->_mapperSoftCredit);
 112     $this->setActiveFieldSoftCreditType($this->_mapperSoftCreditType);
 113
 114     // FIXME: we should do this in one place together with Form/MapField.php
 115     $this->_contactIdIndex = -1;
 116     $this->_totalAmountIndex = -1;
 117     $this->_contributionTypeIndex = -1;
 118
 119     $index = 0;
 120     foreach ($this->_mapperKeys as $key) {
 121       switch ($key) {
 122         case 'contribution_contact_id':
 123           $this->_contactIdIndex = $index;
 124           break;
 125
 126         case 'total_amount':
 127           $this->_totalAmountIndex = $index;
 128           break;
 129
 130         case 'financial_type':
 131           $this->_contributionTypeIndex = $index;
 132           break;
 133       }
 134       $index++;
 135     }
 136   }
 137
 138   /**
 139    * Handle the values in mapField mode.
 140    *
 141    * @param array $values
 142    *   The array of values belonging to this line.
 143    *
 144    * @return bool
 145    */
 146   public function mapField(&$values) {
 147     return CRM_Import_Parser::VALID;
 148   }
 149
 150   /**
 151    * Handle the values in preview mode.
 152    *
 153    * @param array $values
 154    *   The array of values belonging to this line.
 155    *
 156    * @return bool
 157    *   the result of this processing
 158    */
 159   public function preview(&$values) {
 160     return $this->summary($values);
 161   }
 162
 163   /**
 164    * Handle the values in summary mode.
 165    *
 166    * @param array $values
 167    *   The array of values belonging to this line.
 168    *
 169    * @return bool
 170    *   the result of this processing
 171    */
 172   public function summary(&$values) {
 173     $erroneousField = NULL;
 174     $response = $this->setActiveFieldValues($values, $erroneousField);
 175
 176     $params = &$this->getActiveFieldParams();
 177     $errorMessage = NULL;
 178
 179     //for date-Formats
 180     $errorMessage = implode('; ', $this->formatDateFields($params));
 181     //date-Format part ends
 182
 183     $params['contact_type'] = 'Contribution';
 184
 185     //checking error in custom data
 186     CRM_Contact_Import_Parser_Contact::isErrorInCustomData($params, $errorMessage);
 187
 188     if ($errorMessage) {
 189       $tempMsg = "Invalid value for field(s) : $errorMessage";
 190       array_unshift($values, $tempMsg);
 191       $errorMessage = NULL;
 192       return CRM_Import_Parser::ERROR;
 193     }
 194
 195     return CRM_Import_Parser::VALID;
 196   }
 197
 198   /**
 199    * Handle the values in import mode.
 200    *
 201    * @param int $onDuplicate
 202    *   The code for what action to take on duplicates.
 203    * @param array $values
 204    *   The array of values belonging to this line.
 205    *
 206    * @return bool
 207    *   the result of this processing
 208    */
 209   public function import($onDuplicate, &$values) {
 210     // first make sure this is a valid line
 211     $response = $this->summary($values);
 212     if ($response != CRM_Import_Parser::VALID) {
 213       return $response;
 214     }
 215
 216     $params = &$this->getActiveFieldParams();
 217     $formatted = ['version' => 3, 'skipRecentView' => TRUE, 'skipCleanMoney' => FALSE];
 218
 219     //CRM-10994
 220     if (isset($params['total_amount']) && $params['total_amount'] == 0) {
 221       $params['total_amount'] = '0.00';
 222     }
 223     $this->formatInput($params, $formatted);
 224
 225     static $indieFields = NULL;
 226     if ($indieFields == NULL) {
 227       $tempIndieFields = CRM_Contribute_DAO_Contribution::import();
 228       $indieFields = $tempIndieFields;
 229     }
 230
 231     $paramValues = [];
 232     foreach ($params as $key => $field) {
 233       if ($field == NULL || $field === '') {
 234         continue;
 235       }
 236       $paramValues[$key] = $field;
 237     }
 238
 239     //import contribution record according to select contact type
 240     if ($onDuplicate == CRM_Import_Parser::DUPLICATE_SKIP &&
 241       (!empty($paramValues['contribution_contact_id']) || !empty($paramValues['external_identifier']))
 242     ) {
 243       $paramValues['contact_type'] = $this->_contactType;
 244     }
 245     elseif ($onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE &&
 246       (!empty($paramValues['contribution_id']) || !empty($values['trxn_id']) || !empty($paramValues['invoice_id']))
 247     ) {
 248       $paramValues['contact_type'] = $this->_contactType;
 249     }
 250     elseif (!empty($params['soft_credit'])) {
 251       $paramValues['contact_type'] = $this->_contactType;
 252     }
 253     elseif (!empty($paramValues['pledge_payment'])) {
 254       $paramValues['contact_type'] = $this->_contactType;
 255     }
 256
 257     //need to pass $onDuplicate to check import mode.
 258     if (!empty($paramValues['pledge_payment'])) {
 259       $paramValues['onDuplicate'] = $onDuplicate;
 260     }
 261     $formatError = $this->deprecatedFormatParams($paramValues, $formatted, TRUE, $onDuplicate);
 262
 263     if ($formatError) {
 264       array_unshift($values, $formatError['error_message']);
 265       if (CRM_Utils_Array::value('error_data', $formatError) == 'soft_credit') {
 266         return CRM_Contribute_Import_Parser::SOFT_CREDIT_ERROR;
 267       }
 268       elseif (CRM_Utils_Array::value('error_data', $formatError) == 'pledge_payment') {
 269         return CRM_Contribute_Import_Parser::PLEDGE_PAYMENT_ERROR;
 270       }
 271       return CRM_Import_Parser::ERROR;
 272     }
 273
 274     if ($onDuplicate != CRM_Import_Parser::DUPLICATE_UPDATE) {
 275       $formatted['custom'] = CRM_Core_BAO_CustomField::postProcess($formatted,
 276         NULL,
 277         'Contribution'
 278       );
 279     }
 280     else {
 281       //fix for CRM-2219 - Update Contribution
 282       // onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE
 283       if (!empty($paramValues['invoice_id']) || !empty($paramValues['trxn_id']) || !empty($paramValues['contribution_id'])) {
 284         $dupeIds = [
 285           'id' => CRM_Utils_Array::value('contribution_id', $paramValues),
 286           'trxn_id' => CRM_Utils_Array::value('trxn_id', $paramValues),
 287           'invoice_id' => CRM_Utils_Array::value('invoice_id', $paramValues),
 288         ];
 289
 290         $ids['contribution'] = CRM_Contribute_BAO_Contribution::checkDuplicateIds($dupeIds);
 291
 292         if ($ids['contribution']) {
 293           $formatted['id'] = $ids['contribution'];
 294           $formatted['custom'] = CRM_Core_BAO_CustomField::postProcess($formatted,
 295             $formatted['id'],
 296             'Contribution'
 297           );
 298           //process note
 299           if (!empty($paramValues['note'])) {
 300             $noteID = [];
 301             $contactID = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $ids['contribution'], 'contact_id');
 302             $daoNote = new CRM_Core_BAO_Note();
 303             $daoNote->entity_table = 'civicrm_contribution';
 304             $daoNote->entity_id = $ids['contribution'];
 305             if ($daoNote->find(TRUE)) {
 306               $noteID['id'] = $daoNote->id;
 307             }
 308
 309             $noteParams = [
 310               'entity_table' => 'civicrm_contribution',
 311               'note' => $paramValues['note'],
 312               'entity_id' => $ids['contribution'],
 313               'contact_id' => $contactID,
 314             ];
 315             CRM_Core_BAO_Note::add($noteParams, $noteID);
 316             unset($formatted['note']);
 317           }
 318
 319           //need to check existing soft credit contribution, CRM-3968
 320           if (!empty($formatted['soft_credit'])) {
 321             $dupeSoftCredit = [
 322               'contact_id' => $formatted['soft_credit'],
 323               'contribution_id' => $ids['contribution'],
 324             ];
 325
 326             //Delete all existing soft Contribution from contribution_soft table for pcp_id is_null
 327             $existingSoftCredit = CRM_Contribute_BAO_ContributionSoft::getSoftContribution($dupeSoftCredit['contribution_id']);
 328             if (isset($existingSoftCredit['soft_credit']) && !empty($existingSoftCredit['soft_credit'])) {
 329               foreach ($existingSoftCredit['soft_credit'] as $key => $existingSoftCreditValues) {
 330                 if (!empty($existingSoftCreditValues['soft_credit_id'])) {
 331                   civicrm_api3('ContributionSoft', 'delete', [
 332                     'id' => $existingSoftCreditValues['soft_credit_id'],
 333                     'pcp_id' => NULL,
 334                   ]);
 335                 }
 336               }
 337             }
 338           }
 339
 340           $newContribution = CRM_Contribute_BAO_Contribution::create($formatted, $ids);
 341           $this->_newContributions[] = $newContribution->id;
 342
 343           //return soft valid since we need to show how soft credits were added
 344           if (!empty($formatted['soft_credit'])) {
 345             return CRM_Contribute_Import_Parser::SOFT_CREDIT;
 346           }
 347
 348           // process pledge payment assoc w/ the contribution
 349           return self::processPledgePayments($formatted);
 350
 351           return CRM_Import_Parser::VALID;
 352         }
 353         else {
 354           $labels = [
 355             'id' => 'Contribution ID',
 356             'trxn_id' => 'Transaction ID',
 357             'invoice_id' => 'Invoice ID',
 358           ];
 359           foreach ($dupeIds as $k => $v) {
 360             if ($v) {
 361               $errorMsg[] = "$labels[$k] $v";
 362             }
 363           }
 364           $errorMsg = implode(' AND ', $errorMsg);
 365           array_unshift($values, 'Matching Contribution record not found for ' . $errorMsg . '. Row was skipped.');
 366           return CRM_Import_Parser::ERROR;
 367         }
 368       }
 369     }
 370
 371     if ($this->_contactIdIndex < 0) {
 372       // set the contact type if its not set
 373       if (!isset($paramValues['contact_type'])) {
 374         $paramValues['contact_type'] = $this->_contactType;
 375       }
 376
 377       $error = $this->checkContactDuplicate($paramValues);
 378
 379       if (CRM_Core_Error::isAPIError($error, CRM_Core_ERROR::DUPLICATE_CONTACT)) {
 380         $matchedIDs = explode(',', $error['error_message']['params'][0]);
 381         if (count($matchedIDs) > 1) {
 382           array_unshift($values, 'Multiple matching contact records detected for this row. The contribution was not imported');
 383           return CRM_Import_Parser::ERROR;
 384         }
 385         else {
 386           $cid = $matchedIDs[0];
 387           $formatted['contact_id'] = $cid;
 388
 389           $newContribution = civicrm_api('contribution', 'create', $formatted);
 390           if (civicrm_error($newContribution)) {
 391             if (is_array($newContribution['error_message'])) {
 392               array_unshift($values, $newContribution['error_message']['message']);
 393               if ($newContribution['error_message']['params'][0]) {
 394                 return CRM_Import_Parser::DUPLICATE;
 395               }
 396             }
 397             else {
 398               array_unshift($values, $newContribution['error_message']);
 399               return CRM_Import_Parser::ERROR;
 400             }
 401           }
 402
 403           $this->_newContributions[] = $newContribution['id'];
 404           $formatted['contribution_id'] = $newContribution['id'];
 405
 406           //return soft valid since we need to show how soft credits were added
 407           if (!empty($formatted['soft_credit'])) {
 408             return CRM_Contribute_Import_Parser::SOFT_CREDIT;
 409           }
 410
 411           // process pledge payment assoc w/ the contribution
 412           return self::processPledgePayments($formatted);
 413
 414           return CRM_Import_Parser::VALID;
 415         }
 416       }
 417       else {
 418         // Using new Dedupe rule.
 419         $ruleParams = [
 420           'contact_type' => $this->_contactType,
 421           'used' => 'Unsupervised',
 422         ];
 423         $fieldsArray = CRM_Dedupe_BAO_Rule::dedupeRuleFields($ruleParams);
 424         $disp = NULL;
 425         foreach ($fieldsArray as $value) {
 426           if (array_key_exists(trim($value), $params)) {
 427             $paramValue = $params[trim($value)];
 428             if (is_array($paramValue)) {
 429               $disp .= $params[trim($value)][0][trim($value)] . " ";
 430             }
 431             else {
 432               $disp .= $params[trim($value)] . " ";
 433             }
 434           }
 435         }
 436
 437         if (!empty($params['external_identifier'])) {
 438           if ($disp) {
 439             $disp .= "AND {$params['external_identifier']}";
 440           }
 441           else {
 442             $disp = $params['external_identifier'];
 443           }
 444         }
 445
 446         array_unshift($values, 'No matching Contact found for (' . $disp . ')');
 447         return CRM_Import_Parser::ERROR;
 448       }
 449     }
 450     else {
 451       if (!empty($paramValues['external_identifier'])) {
 452         $checkCid = new CRM_Contact_DAO_Contact();
 453         $checkCid->external_identifier = $paramValues['external_identifier'];
 454         $checkCid->find(TRUE);
 455         if ($checkCid->id != $formatted['contact_id']) {
 456           array_unshift($values, 'Mismatch of External ID:' . $paramValues['external_identifier'] . ' and Contact Id:' . $formatted['contact_id']);
 457           return CRM_Import_Parser::ERROR;
 458         }
 459       }
 460       $newContribution = civicrm_api('contribution', 'create', $formatted);
 461       if (civicrm_error($newContribution)) {
 462         if (is_array($newContribution['error_message'])) {
 463           array_unshift($values, $newContribution['error_message']['message']);
 464           if ($newContribution['error_message']['params'][0]) {
 465             return CRM_Import_Parser::DUPLICATE;
 466           }
 467         }
 468         else {
 469           array_unshift($values, $newContribution['error_message']);
 470           return CRM_Import_Parser::ERROR;
 471         }
 472       }
 473
 474       $this->_newContributions[] = $newContribution['id'];
 475       $formatted['contribution_id'] = $newContribution['id'];
 476
 477       //return soft valid since we need to show how soft credits were added
 478       if (!empty($formatted['soft_credit'])) {
 479         return CRM_Contribute_Import_Parser::SOFT_CREDIT;
 480       }
 481
 482       // process pledge payment assoc w/ the contribution
 483       return self::processPledgePayments($formatted);
 484
 485       return CRM_Import_Parser::VALID;
 486     }
 487   }
 488
 489   /**
 490    * Process pledge payments.
 491    *
 492    * @param array $formatted
 493    *
 494    * @return int
 495    */
 496   public function processPledgePayments(&$formatted) {
 497     if (!empty($formatted['pledge_payment_id']) && !empty($formatted['pledge_id'])) {
 498       //get completed status
 499       $completeStatusID = CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Completed');
 500
 501       //need to update payment record to map contribution_id
 502       CRM_Core_DAO::setFieldValue('CRM_Pledge_DAO_PledgePayment', $formatted['pledge_payment_id'],
 503         'contribution_id', $formatted['contribution_id']
 504       );
 505
 506       CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($formatted['pledge_id'],
 507         [$formatted['pledge_payment_id']],
 508         $completeStatusID,
 509         NULL,
 510         $formatted['total_amount']
 511       );
 512
 513       return CRM_Contribute_Import_Parser::PLEDGE_PAYMENT;
 514     }
 515   }
 516
 517   /**
 518    * Get the array of successfully imported contribution id's
 519    *
 520    * @return array
 521    */
 522   public function &getImportedContributions() {
 523     return $this->_newContributions;
 524   }
 525
 526   /**
 527    * The initializer code, called before the processing.
 528    */
 529   public function fini() {
 530   }
 531
 532   /**
 533    * Format date fields from input to mysql.
 534    *
 535    * @param array $params
 536    *
 537    * @return array
 538    *   Error messages, if any.
 539    */
 540   public function formatDateFields(&$params) {
 541     $errorMessage = [];
 542     $dateType = CRM_Core_Session::singleton()->get('dateTypes');
 543     foreach ($params as $key => $val) {
 544       if ($val) {
 545         switch ($key) {
 546           case 'receive_date':
 547             if ($dateValue = CRM_Utils_Date::formatDate($params[$key], $dateType)) {
 548               $params[$key] = $dateValue;
 549             }
 550             else {
 551               $errorMessage[] = ts('Receive Date');
 552             }
 553             break;
 554
 555           case 'cancel_date':
 556             if ($dateValue = CRM_Utils_Date::formatDate($params[$key], $dateType)) {
 557               $params[$key] = $dateValue;
 558             }
 559             else {
 560               $errorMessage[] = ts('Cancel Date');
 561             }
 562             break;
 563
 564           case 'receipt_date':
 565             if ($dateValue = CRM_Utils_Date::formatDate($params[$key], $dateType)) {
 566               $params[$key] = $dateValue;
 567             }
 568             else {
 569               $errorMessage[] = ts('Receipt date');
 570             }
 571             break;
 572
 573           case 'thankyou_date':
 574             if ($dateValue = CRM_Utils_Date::formatDate($params[$key], $dateType)) {
 575               $params[$key] = $dateValue;
 576             }
 577             else {
 578               $errorMessage[] = ts('Thankyou Date');
 579             }
 580             break;
 581         }
 582       }
 583     }
 584     return $errorMessage;
 585   }
 586
 587   /**
 588    * Format input params to suit api handling.
 589    *
 590    * Over time all the parts of  deprecatedFormatParams
 591    * and all the parts of the import function on this class that relate to
 592    * reformatting input should be moved here and tests should be added in
 593    * CRM_Contribute_Import_Parser_ContributionTest.
 594    *
 595    * @param array $params
 596    * @param array $formatted
 597    */
 598   public function formatInput(&$params, &$formatted = []) {
 599     $dateType = CRM_Core_Session::singleton()->get('dateTypes');
 600     $customDataType = !empty($params['contact_type']) ? $params['contact_type'] : 'Contribution';
 601     $customFields = CRM_Core_BAO_CustomField::getFields($customDataType);
 602     // @todo call formatDateFields & move custom data handling there.
 603     // Also note error handling for dates is currently in  deprecatedFormatParams
 604     // we should use the error handling in formatDateFields.
 605     foreach ($params as $key => $val) {
 606       // @todo - call formatDateFields instead.
 607       if ($val) {
 608         switch ($key) {
 609           case 'receive_date':
 610           case 'cancel_date':
 611           case 'receipt_date':
 612           case 'thankyou_date':
 613             $params[$key] = CRM_Utils_Date::formatDate($params[$key], $dateType);
 614             break;
 615
 616           case 'pledge_payment':
 617             $params[$key] = CRM_Utils_String::strtobool($val);
 618             break;
 619
 620         }
 621         if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
 622           if ($customFields[$customFieldID]['data_type'] == 'Date') {
 623             CRM_Contact_Import_Parser_Contact::formatCustomDate($params, $formatted, $dateType, $key);
 624             unset($params[$key]);
 625           }
 626           elseif ($customFields[$customFieldID]['data_type'] == 'Boolean') {
 627             $params[$key] = CRM_Utils_String::strtoboolstr($val);
 628           }
 629         }
 630       }
 631     }
 632   }
 633
 634   /**
 635    * take the input parameter list as specified in the data model and
 636    * convert it into the same format that we use in QF and BAO object
 637    *
 638    * @param array $params
 639    *   Associative array of property name/value.
 640    *                             pairs to insert in new contact.
 641    * @param array $values
 642    *   The reformatted properties that we can use internally.
 643    *                            '
 644    *
 645    * @param bool $create
 646    * @param null $onDuplicate
 647    *
 648    * @return array|CRM_Error
 649    */
 650   private function deprecatedFormatParams($params, &$values, $create = FALSE, $onDuplicate = NULL) {
 651     require_once 'CRM/Utils/DeprecatedUtils.php';
 652     // copy all the contribution fields as is
 653     require_once 'api/v3/utils.php';
 654     $fields = CRM_Core_DAO::getExportableFieldsWithPseudoConstants('CRM_Contribute_BAO_Contribution');
 655
 656     _civicrm_api3_store_values($fields, $params, $values);
 657
 658     $customFields = CRM_Core_BAO_CustomField::getFields('Contribution', FALSE, FALSE, NULL, NULL, FALSE, FALSE, FALSE);
 659
 660     foreach ($params as $key => $value) {
 661       // ignore empty values or empty arrays etc
 662       if (CRM_Utils_System::isNull($value)) {
 663         continue;
 664       }
 665
 666       // Handling Custom Data
 667       if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
 668         $values[$key] = $value;
 669         $type = $customFields[$customFieldID]['html_type'];
 670         if ($type == 'CheckBox' || $type == 'Multi-Select') {
 671           $mulValues = explode(',', $value);
 672           $customOption = CRM_Core_BAO_CustomOption::getCustomOption($customFieldID, TRUE);
 673           $values[$key] = [];
 674           foreach ($mulValues as $v1) {
 675             foreach ($customOption as $customValueID => $customLabel) {
 676               $customValue = $customLabel['value'];
 677               if ((strtolower($customLabel['label']) == strtolower(trim($v1))) ||
 678                 (strtolower($customValue) == strtolower(trim($v1)))
 679               ) {
 680                 if ($type == 'CheckBox') {
 681                   $values[$key][$customValue] = 1;
 682                 }
 683                 else {
 684                   $values[$key][] = $customValue;
 685                 }
 686               }
 687             }
 688           }
 689         }
 690         elseif ($type == 'Select' || $type == 'Radio' ||
 691           ($type == 'Autocomplete-Select' &&
 692             $customFields[$customFieldID]['data_type'] == 'String'
 693           )
 694         ) {
 695           $customOption = CRM_Core_BAO_CustomOption::getCustomOption($customFieldID, TRUE);
 696           foreach ($customOption as $customFldID => $customValue) {
 697             $val = CRM_Utils_Array::value('value', $customValue);
 698             $label = CRM_Utils_Array::value('label', $customValue);
 699             $label = strtolower($label);
 700             $value = strtolower(trim($value));
 701             if (($value == $label) || ($value == strtolower($val))) {
 702               $values[$key] = $val;
 703             }
 704           }
 705         }
 706       }
 707
 708       switch ($key) {
 709         case 'contribution_contact_id':
 710           if (!CRM_Utils_Rule::integer($value)) {
 711             return civicrm_api3_create_error("contact_id not valid: $value");
 712           }
 713           $dao = new CRM_Core_DAO();
 714           $qParams = [];
 715           $svq = $dao->singleValueQuery("SELECT is_deleted FROM civicrm_contact WHERE id = $value",
 716             $qParams
 717           );
 718           if (!isset($svq)) {
 719             return civicrm_api3_create_error("Invalid Contact ID: There is no contact record with contact_id = $value.");
 720           }
 721           elseif ($svq == 1) {
 722             return civicrm_api3_create_error("Invalid Contact ID: contact_id $value is a soft-deleted contact.");
 723           }
 724
 725           $values['contact_id'] = $values['contribution_contact_id'];
 726           unset($values['contribution_contact_id']);
 727           break;
 728
 729         case 'contact_type':
 730           // import contribution record according to select contact type
 731           require_once 'CRM/Contact/DAO/Contact.php';
 732           $contactType = new CRM_Contact_DAO_Contact();
 733           $contactId = CRM_Utils_Array::value('contribution_contact_id', $params);
 734           $externalId = CRM_Utils_Array::value('external_identifier', $params);
 735           $email = CRM_Utils_Array::value('email', $params);
 736           //when insert mode check contact id or external identifier
 737           if ($contactId || $externalId) {
 738             $contactType->id = $contactId;
 739             $contactType->external_identifier = $externalId;
 740             if ($contactType->find(TRUE)) {
 741               if ($params['contact_type'] != $contactType->contact_type) {
 742                 return civicrm_api3_create_error("Contact Type is wrong: $contactType->contact_type");
 743               }
 744             }
 745           }
 746           elseif ($email) {
 747             if (!CRM_Utils_Rule::email($email)) {
 748               return civicrm_api3_create_error("Invalid email address $email provided. Row was skipped");
 749             }
 750
 751             // get the contact id from duplicate contact rule, if more than one contact is returned
 752             // we should return error, since current interface allows only one-one mapping
 753             $emailParams = ['email' => $email, 'contact_type' => $params['contact_type']];
 754             $checkDedupe = _civicrm_api3_deprecated_duplicate_formatted_contact($emailParams);
 755             if (!$checkDedupe['is_error']) {
 756               return civicrm_api3_create_error("Invalid email address(doesn't exist) $email. Row was skipped");
 757             }
 758             else {
 759               $matchingContactIds = explode(',', $checkDedupe['error_message']['params'][0]);
 760               if (count($matchingContactIds) > 1) {
 761                 return civicrm_api3_create_error("Invalid email address(duplicate) $email. Row was skipped");
 762               }
 763               elseif (count($matchingContactIds) == 1) {
 764                 $params['contribution_contact_id'] = $matchingContactIds[0];
 765               }
 766             }
 767           }
 768           elseif (!empty($params['contribution_id']) || !empty($params['trxn_id']) || !empty($params['invoice_id'])) {
 769             // when update mode check contribution id or trxn id or
 770             // invoice id
 771             $contactId = new CRM_Contribute_DAO_Contribution();
 772             if (!empty($params['contribution_id'])) {
 773               $contactId->id = $params['contribution_id'];
 774             }
 775             elseif (!empty($params['trxn_id'])) {
 776               $contactId->trxn_id = $params['trxn_id'];
 777             }
 778             elseif (!empty($params['invoice_id'])) {
 779               $contactId->invoice_id = $params['invoice_id'];
 780             }
 781             if ($contactId->find(TRUE)) {
 782               $contactType->id = $contactId->contact_id;
 783               if ($contactType->find(TRUE)) {
 784                 if ($params['contact_type'] != $contactType->contact_type) {
 785                   return civicrm_api3_create_error("Contact Type is wrong: $contactType->contact_type");
 786                 }
 787               }
 788             }
 789           }
 790           else {
 791             if ($onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE) {
 792               return civicrm_api3_create_error("Empty Contribution and Invoice and Transaction ID. Row was skipped.");
 793             }
 794           }
 795           break;
 796
 797         case 'receive_date':
 798         case 'cancel_date':
 799         case 'receipt_date':
 800         case 'thankyou_date':
 801           if (!CRM_Utils_Rule::dateTime($value)) {
 802             return civicrm_api3_create_error("$key not a valid date: $value");
 803           }
 804           break;
 805
 806         case 'non_deductible_amount':
 807         case 'total_amount':
 808         case 'fee_amount':
 809         case 'net_amount':
 810           // @todo add test like testPaymentTypeLabel & remove these lines as we can anticipate error will still be caught & handled.
 811           if (!CRM_Utils_Rule::money($value)) {
 812             return civicrm_api3_create_error("$key not a valid amount: $value");
 813           }
 814           break;
 815
 816         case 'currency':
 817           if (!CRM_Utils_Rule::currencyCode($value)) {
 818             return civicrm_api3_create_error("currency not a valid code: $value");
 819           }
 820           break;
 821
 822         case 'financial_type':
 823           // @todo add test like testPaymentTypeLabel & remove these lines in favour of 'default' part of switch.
 824           require_once 'CRM/Contribute/PseudoConstant.php';
 825           $contriTypes = CRM_Contribute_PseudoConstant::financialType();
 826           foreach ($contriTypes as $val => $type) {
 827             if (strtolower($value) == strtolower($type)) {
 828               $values['financial_type_id'] = $val;
 829               break;
 830             }
 831           }
 832           if (empty($values['financial_type_id'])) {
 833             return civicrm_api3_create_error("Financial Type is not valid: $value");
 834           }
 835           break;
 836
 837         case 'soft_credit':
 838           // import contribution record according to select contact type
 839           // validate contact id and external identifier.
 840           $value[$key] = $mismatchContactType = $softCreditContactIds = '';
 841           if (isset($params[$key]) && is_array($params[$key])) {
 842             foreach ($params[$key] as $softKey => $softParam) {
 843               $contactId = CRM_Utils_Array::value('contact_id', $softParam);
 844               $externalId = CRM_Utils_Array::value('external_identifier', $softParam);
 845               $email = CRM_Utils_Array::value('email', $softParam);
 846               if ($contactId || $externalId) {
 847                 require_once 'CRM/Contact/DAO/Contact.php';
 848                 $contact = new CRM_Contact_DAO_Contact();
 849                 $contact->id = $contactId;
 850                 $contact->external_identifier = $externalId;
 851                 $errorMsg = NULL;
 852                 if (!$contact->find(TRUE)) {
 853                   $field = $contactId ? ts('Contact ID') : ts('External ID');
 854                   $errorMsg = ts("Soft Credit %1 - %2 doesn't exist. Row was skipped.",
 855                     [1 => $field, 2 => $contactId ? $contactId : $externalId]);
 856                 }
 857
 858                 if ($errorMsg) {
 859                   return civicrm_api3_create_error($errorMsg);
 860                 }
 861
 862                 // finally get soft credit contact id.
 863                 $values[$key][$softKey] = $softParam;
 864                 $values[$key][$softKey]['contact_id'] = $contact->id;
 865               }
 866               elseif ($email) {
 867                 if (!CRM_Utils_Rule::email($email)) {
 868                   return civicrm_api3_create_error("Invalid email address $email provided for Soft Credit. Row was skipped");
 869                 }
 870
 871                 // get the contact id from duplicate contact rule, if more than one contact is returned
 872                 // we should return error, since current interface allows only one-one mapping
 873                 $emailParams = ['email' => $email, 'contact_type' => $params['contact_type']];
 874                 $checkDedupe = _civicrm_api3_deprecated_duplicate_formatted_contact($emailParams);
 875                 if (!$checkDedupe['is_error']) {
 876                   return civicrm_api3_create_error("Invalid email address(doesn't exist) $email for Soft Credit. Row was skipped");
 877                 }
 878                 else {
 879                   $matchingContactIds = explode(',', $checkDedupe['error_message']['params'][0]);
 880                   if (count($matchingContactIds) > 1) {
 881                     return civicrm_api3_create_error("Invalid email address(duplicate) $email for Soft Credit. Row was skipped");
 882                   }
 883                   elseif (count($matchingContactIds) == 1) {
 884                     $contactId = $matchingContactIds[0];
 885                     unset($softParam['email']);
 886                     $values[$key][$softKey] = $softParam + ['contact_id' => $contactId];
 887                   }
 888                 }
 889               }
 890             }
 891           }
 892           break;
 893
 894         case 'pledge_payment':
 895         case 'pledge_id':
 896
 897           // giving respect to pledge_payment flag.
 898           if (empty($params['pledge_payment'])) {
 899             continue;
 900           }
 901
 902           // get total amount of from import fields
 903           $totalAmount = CRM_Utils_Array::value('total_amount', $params);
 904
 905           $onDuplicate = CRM_Utils_Array::value('onDuplicate', $params);
 906
 907           // we need to get contact id $contributionContactID to
 908           // retrieve pledge details as well as to validate pledge ID
 909
 910           // first need to check for update mode
 911           if ($onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE &&
 912             ($params['contribution_id'] || $params['trxn_id'] || $params['invoice_id'])
 913           ) {
 914             $contribution = new CRM_Contribute_DAO_Contribution();
 915             if ($params['contribution_id']) {
 916               $contribution->id = $params['contribution_id'];
 917             }
 918             elseif ($params['trxn_id']) {
 919               $contribution->trxn_id = $params['trxn_id'];
 920             }
 921             elseif ($params['invoice_id']) {
 922               $contribution->invoice_id = $params['invoice_id'];
 923             }
 924
 925             if ($contribution->find(TRUE)) {
 926               $contributionContactID = $contribution->contact_id;
 927               if (!$totalAmount) {
 928                 $totalAmount = $contribution->total_amount;
 929               }
 930             }
 931             else {
 932               return civicrm_api3_create_error('No match found for specified contact in pledge payment data. Row was skipped.');
 933             }
 934           }
 935           else {
 936             // first get the contact id for given contribution record.
 937             if (!empty($params['contribution_contact_id'])) {
 938               $contributionContactID = $params['contribution_contact_id'];
 939             }
 940             elseif (!empty($params['external_identifier'])) {
 941               require_once 'CRM/Contact/DAO/Contact.php';
 942               $contact = new CRM_Contact_DAO_Contact();
 943               $contact->external_identifier = $params['external_identifier'];
 944               if ($contact->find(TRUE)) {
 945                 $contributionContactID = $params['contribution_contact_id'] = $values['contribution_contact_id'] = $contact->id;
 946               }
 947               else {
 948                 return civicrm_api3_create_error('No match found for specified contact in pledge payment data. Row was skipped.');
 949               }
 950             }
 951             else {
 952               // we need to get contribution contact using de dupe
 953               $error = _civicrm_api3_deprecated_check_contact_dedupe($params);
 954
 955               if (isset($error['error_message']['params'][0])) {
 956                 $matchedIDs = explode(',', $error['error_message']['params'][0]);
 957
 958                 // check if only one contact is found
 959                 if (count($matchedIDs) > 1) {
 960                   return civicrm_api3_create_error($error['error_message']['message']);
 961                 }
 962                 else {
 963                   $contributionContactID = $params['contribution_contact_id'] = $values['contribution_contact_id'] = $matchedIDs[0];
 964                 }
 965               }
 966               else {
 967                 return civicrm_api3_create_error('No match found for specified contact in contribution data. Row was skipped.');
 968               }
 969             }
 970           }
 971
 972           if (!empty($params['pledge_id'])) {
 973             if (CRM_Core_DAO::getFieldValue('CRM_Pledge_DAO_Pledge', $params['pledge_id'], 'contact_id') != $contributionContactID) {
 974               return civicrm_api3_create_error('Invalid Pledge ID provided. Contribution row was skipped.');
 975             }
 976             $values['pledge_id'] = $params['pledge_id'];
 977           }
 978           else {
 979             // check if there are any pledge related to this contact, with payments pending or in progress
 980             require_once 'CRM/Pledge/BAO/Pledge.php';
 981             $pledgeDetails = CRM_Pledge_BAO_Pledge::getContactPledges($contributionContactID);
 982
 983             if (empty($pledgeDetails)) {
 984               return civicrm_api3_create_error('No open pledges found for this contact. Contribution row was skipped.');
 985             }
 986             elseif (count($pledgeDetails) > 1) {
 987               return civicrm_api3_create_error('This contact has more than one open pledge. Unable to determine which pledge to apply the contribution to. Contribution row was skipped.');
 988             }
 989
 990             // this mean we have only one pending / in progress pledge
 991             $values['pledge_id'] = $pledgeDetails[0];
 992           }
 993
 994           // we need to check if oldest payment amount equal to contribution amount
 995           require_once 'CRM/Pledge/BAO/PledgePayment.php';
 996           $pledgePaymentDetails = CRM_Pledge_BAO_PledgePayment::getOldestPledgePayment($values['pledge_id']);
 997
 998           if ($pledgePaymentDetails['amount'] == $totalAmount) {
 999             $values['pledge_payment_id'] = $pledgePaymentDetails['id'];
1000           }
1001           else {
1002             return civicrm_api3_create_error('Contribution and Pledge Payment amount mismatch for this record. Contribution row was skipped.');
1003           }
1004           break;
1005
1006         default:
1007           // Hande name or label for fields with options.
1008           if (isset($fields[$key]) &&
1009             // Yay - just for a surprise we are inconsistent on whether we pass the pseudofield (payment_instrument)
1010             // or the field name (contribution_status_id)
1011             (!empty($fields[$key]['is_pseudofield_for']) || !empty($fields[$key]['pseudoconstant']))
1012           ) {
1013             $realField = $fields[$key]['is_pseudofield_for'] ?? $key;
1014             $realFieldSpec = $fields[$realField];
1015             $values[$key] = $this->parsePseudoConstantField($value, $realFieldSpec);
1016           }
1017           break;
1018       }
1019     }
1020
1021     if (array_key_exists('note', $params)) {
1022       $values['note'] = $params['note'];
1023     }
1024
1025     if ($create) {
1026       // CRM_Contribute_BAO_Contribution::add() handles contribution_source
1027       // So, if $values contains contribution_source, convert it to source
1028       $changes = ['contribution_source' => 'source'];
1029
1030       foreach ($changes as $orgVal => $changeVal) {
1031         if (isset($values[$orgVal])) {
1032           $values[$changeVal] = $values[$orgVal];
1033           unset($values[$orgVal]);
1034         }
1035       }
1036     }
1037
1038     return NULL;
1039   }
1040
1041 }