CRM/Member/Import/Parser/Membership.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 /**
  13  *
  14  * @package CRM
  15  * @copyright CiviCRM LLC https://civicrm.org/licensing
  16  */
  17
  18 /**
  19  * class to parse membership csv files
  20  */
  21 class CRM_Member_Import_Parser_Membership extends CRM_Member_Import_Parser {
  22
  23   protected $_mapperKeys;
  24
  25   private $_membershipTypeIndex;
  26   private $_membershipStatusIndex;
  27
  28   /**
  29    * Array of metadata for all available fields.
  30    *
  31    * @var array
  32    */
  33   protected $fieldMetadata = [];
  34
  35   /**
  36    * Array of successfully imported membership id's
  37    *
  38    * @var array
  39    */
  40   protected $_newMemberships;
  41
  42   /**
  43    * Class constructor.
  44    *
  45    * @param $mapperKeys
  46    */
  47   public function __construct($mapperKeys) {
  48     parent::__construct();
  49     $this->_mapperKeys = $mapperKeys;
  50   }
  51
  52   /**
  53    * The initializer code, called before the processing
  54    *
  55    * @return void
  56    */
  57   public function init() {
  58     $this->fieldMetadata = CRM_Member_BAO_Membership::importableFields($this->_contactType, FALSE);
  59
  60     foreach ($this->fieldMetadata as $name => $field) {
  61       // @todo - we don't really need to do all this.... fieldMetadata is just fine to use as is.
  62       $field['type'] = CRM_Utils_Array::value('type', $field, CRM_Utils_Type::T_INT);
  63       $field['dataPattern'] = CRM_Utils_Array::value('dataPattern', $field, '//');
  64       $field['headerPattern'] = CRM_Utils_Array::value('headerPattern', $field, '//');
  65       $this->addField($name, $field['title'], $field['type'], $field['headerPattern'], $field['dataPattern']);
  66     }
  67
  68     $this->_newMemberships = [];
  69
  70     $this->setActiveFields($this->_mapperKeys);
  71
  72     // FIXME: we should do this in one place together with Form/MapField.php
  73     $this->_membershipTypeIndex = -1;
  74     $this->_membershipStatusIndex = -1;
  75
  76     $index = 0;
  77     foreach ($this->_mapperKeys as $key) {
  78       switch ($key) {
  79
  80         case 'membership_type_id':
  81           $this->_membershipTypeIndex = $index;
  82           break;
  83
  84         case 'status_id':
  85           $this->_membershipStatusIndex = $index;
  86           break;
  87       }
  88       $index++;
  89     }
  90   }
  91
  92   /**
  93    * Handle the values in mapField mode.
  94    *
  95    * @param array $values
  96    *   The array of values belonging to this line.
  97    *
  98    * @return bool
  99    */
 100   public function mapField(&$values) {
 101     return CRM_Import_Parser::VALID;
 102   }
 103
 104   /**
 105    * Handle the values in preview mode.
 106    *
 107    * @param array $values
 108    *   The array of values belonging to this line.
 109    *
 110    * @return bool
 111    *   the result of this processing
 112    */
 113   public function preview(&$values) {
 114     return $this->summary($values);
 115   }
 116
 117   /**
 118    * Handle the values in summary mode.
 119    *
 120    * @param array $values
 121    *   The array of values belonging to this line.
 122    *
 123    * @return bool
 124    *   the result of this processing
 125    */
 126   public function summary(&$values) {
 127     $erroneousField = NULL;
 128     $this->setActiveFieldValues($values, $erroneousField);
 129
 130     $errorRequired = FALSE;
 131
 132     if ($this->_membershipTypeIndex < 0) {
 133       $errorRequired = TRUE;
 134     }
 135     else {
 136       $errorRequired = !CRM_Utils_Array::value($this->_membershipTypeIndex, $values);
 137     }
 138
 139     if ($errorRequired) {
 140       array_unshift($values, ts('Missing required fields'));
 141       return CRM_Import_Parser::ERROR;
 142     }
 143
 144     $params = $this->getActiveFieldParams();
 145     $errorMessage = NULL;
 146
 147     //To check whether start date or join date is provided
 148     if (empty($params['membership_start_date']) && empty($params['membership_join_date'])) {
 149       $errorMessage = 'Membership Start Date is required to create a memberships.';
 150       CRM_Contact_Import_Parser_Contact::addToErrorMsg('Start Date', $errorMessage);
 151     }
 152
 153     //for date-Formats
 154     $session = CRM_Core_Session::singleton();
 155     $dateType = $session->get('dateTypes');
 156     foreach ($params as $key => $val) {
 157
 158       if ($val) {
 159         switch ($key) {
 160           case 'membership_join_date':
 161             if (CRM_Utils_Date::convertToDefaultDate($params, $dateType, $key)) {
 162               if (!CRM_Utils_Rule::date($params[$key])) {
 163                 CRM_Contact_Import_Parser_Contact::addToErrorMsg('Member Since', $errorMessage);
 164               }
 165             }
 166             else {
 167               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Member Since', $errorMessage);
 168             }
 169             break;
 170
 171           case 'membership_start_date':
 172             if (CRM_Utils_Date::convertToDefaultDate($params, $dateType, $key)) {
 173               if (!CRM_Utils_Rule::date($params[$key])) {
 174                 CRM_Contact_Import_Parser_Contact::addToErrorMsg('Start Date', $errorMessage);
 175               }
 176             }
 177             else {
 178               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Start Date', $errorMessage);
 179             }
 180             break;
 181
 182           case 'membership_end_date':
 183             if (CRM_Utils_Date::convertToDefaultDate($params, $dateType, $key)) {
 184               if (!CRM_Utils_Rule::date($params[$key])) {
 185                 CRM_Contact_Import_Parser_Contact::addToErrorMsg('End date', $errorMessage);
 186               }
 187             }
 188             else {
 189               CRM_Contact_Import_Parser_Contact::addToErrorMsg('End date', $errorMessage);
 190             }
 191             break;
 192
 193           case 'status_override_end_date':
 194             if (CRM_Utils_Date::convertToDefaultDate($params, $dateType, $key)) {
 195               if (!CRM_Utils_Rule::date($params[$key])) {
 196                 CRM_Contact_Import_Parser_Contact::addToErrorMsg('Status Override End Date', $errorMessage);
 197               }
 198             }
 199             else {
 200               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Status Override End Date', $errorMessage);
 201             }
 202             break;
 203
 204           case 'membership_type_id':
 205             // @todo - squish into membership status - can use same lines here too.
 206             $membershipTypes = CRM_Member_PseudoConstant::membershipType();
 207             if (!CRM_Utils_Array::crmInArray($val, $membershipTypes) &&
 208               !array_key_exists($val, $membershipTypes)
 209             ) {
 210               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Membership Type', $errorMessage);
 211             }
 212             break;
 213
 214           case 'status_id':
 215             if (!empty($val) && !$this->parsePseudoConstantField($val, $this->fieldMetadata[$key])) {
 216               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Membership Status', $errorMessage);
 217             }
 218             break;
 219
 220           case 'email':
 221             if (!CRM_Utils_Rule::email($val)) {
 222               CRM_Contact_Import_Parser_Contact::addToErrorMsg('Email Address', $errorMessage);
 223             }
 224         }
 225       }
 226     }
 227     //date-Format part ends
 228
 229     $params['contact_type'] = 'Membership';
 230
 231     //checking error in custom data
 232     CRM_Contact_Import_Parser_Contact::isErrorInCustomData($params, $errorMessage);
 233
 234     if ($errorMessage) {
 235       $tempMsg = "Invalid value for field(s) : $errorMessage";
 236       array_unshift($values, $tempMsg);
 237       $errorMessage = NULL;
 238       return CRM_Import_Parser::ERROR;
 239     }
 240
 241     return CRM_Import_Parser::VALID;
 242   }
 243
 244   /**
 245    * Handle the values in import mode.
 246    *
 247    * @param int $onDuplicate
 248    *   The code for what action to take on duplicates.
 249    * @param array $values
 250    *   The array of values belonging to this line.
 251    *
 252    * @return bool
 253    *   the result of this processing
 254    */
 255   public function import($onDuplicate, &$values) {
 256     try {
 257       // first make sure this is a valid line
 258       $response = $this->summary($values);
 259       if ($response != CRM_Import_Parser::VALID) {
 260         return $response;
 261       }
 262
 263       $params = $this->getActiveFieldParams();
 264
 265       //assign join date equal to start date if join date is not provided
 266       if (empty($params['membership_join_date']) && !empty($params['membership_start_date'])) {
 267         $params['membership_join_date'] = $params['membership_start_date'];
 268       }
 269
 270       $session = CRM_Core_Session::singleton();
 271       $dateType = CRM_Core_Session::singleton()->get('dateTypes');
 272       $formatted = [];
 273       $customDataType = !empty($params['contact_type']) ? $params['contact_type'] : 'Membership';
 274       $customFields = CRM_Core_BAO_CustomField::getFields($customDataType);
 275
 276       // don't add to recent items, CRM-4399
 277       $formatted['skipRecentView'] = TRUE;
 278       $dateLabels = [
 279         'membership_join_date' => ts('Member Since'),
 280         'membership_start_date' => ts('Start Date'),
 281         'membership_end_date' => ts('End Date'),
 282       ];
 283       foreach ($params as $key => $val) {
 284         if ($val) {
 285           switch ($key) {
 286             case 'membership_join_date':
 287             case 'membership_start_date':
 288             case 'membership_end_date':
 289               if (CRM_Utils_Date::convertToDefaultDate($params, $dateType, $key)) {
 290                 if (!CRM_Utils_Rule::date($params[$key])) {
 291                   CRM_Contact_Import_Parser_Contact::addToErrorMsg($dateLabels[$key], $errorMessage);
 292                 }
 293               }
 294               else {
 295                 CRM_Contact_Import_Parser_Contact::addToErrorMsg($dateLabels[$key], $errorMessage);
 296               }
 297               break;
 298
 299             case 'membership_type_id':
 300               if (!is_numeric($val)) {
 301                 unset($params['membership_type_id']);
 302                 $params['membership_type'] = $val;
 303               }
 304               break;
 305
 306             case 'status_id':
 307               // @todo - we can do this based on the presence of 'pseudoconstant' in the metadata rather than field specific.
 308               $params[$key] = $this->parsePseudoConstantField($val, $this->fieldMetadata[$key]);
 309               break;
 310
 311           }
 312           if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
 313             if ($customFields[$customFieldID]['data_type'] == 'Date') {
 314               CRM_Contact_Import_Parser_Contact::formatCustomDate($params, $formatted, $dateType, $key);
 315               unset($params[$key]);
 316             }
 317             elseif ($customFields[$customFieldID]['data_type'] == 'Boolean') {
 318               $params[$key] = CRM_Utils_String::strtoboolstr($val);
 319             }
 320           }
 321         }
 322       }
 323       //date-Format part ends
 324
 325       $formatValues = [];
 326       foreach ($params as $key => $field) {
 327         // ignore empty values or empty arrays etc
 328         if (CRM_Utils_System::isNull($field)) {
 329           continue;
 330         }
 331
 332         $formatValues[$key] = $field;
 333       }
 334
 335       //format params to meet api v2 requirements.
 336       //@todo find a way to test removing this formatting
 337       $formatError = $this->membership_format_params($formatValues, $formatted, TRUE);
 338
 339       if ($onDuplicate != CRM_Import_Parser::DUPLICATE_UPDATE) {
 340         $formatted['custom'] = CRM_Core_BAO_CustomField::postProcess($formatted,
 341           NULL,
 342           'Membership'
 343         );
 344       }
 345       else {
 346         //fix for CRM-2219 Update Membership
 347         // onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE
 348         if (!empty($formatted['member_is_override']) && empty($formatted['status_id'])) {
 349           array_unshift($values, 'Required parameter missing: Status');
 350           return CRM_Import_Parser::ERROR;
 351         }
 352
 353         if (!empty($formatValues['membership_id'])) {
 354           $dao = new CRM_Member_BAO_Membership();
 355           $dao->id = $formatValues['membership_id'];
 356           $dates = ['join_date', 'start_date', 'end_date'];
 357           foreach ($dates as $v) {
 358             if (empty($formatted[$v])) {
 359               $formatted[$v] = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership', $formatValues['membership_id'], $v);
 360             }
 361           }
 362
 363           $formatted['custom'] = CRM_Core_BAO_CustomField::postProcess($formatted,
 364             $formatValues['membership_id'],
 365             'Membership'
 366           );
 367           if ($dao->find(TRUE)) {
 368             if (empty($params['line_item']) && !empty($formatted['membership_type_id'])) {
 369               CRM_Price_BAO_LineItem::getLineItemArray($formatted, NULL, 'membership', $formatted['membership_type_id']);
 370             }
 371
 372             $newMembership = civicrm_api3('Membership', 'create', $formatted);
 373             $this->_newMemberships[] = $newMembership['id'];
 374             return CRM_Import_Parser::VALID;
 375           }
 376           else {
 377             array_unshift($values, 'Matching Membership record not found for Membership ID ' . $formatValues['membership_id'] . '. Row was skipped.');
 378             return CRM_Import_Parser::ERROR;
 379           }
 380         }
 381       }
 382
 383       //Format dates
 384       $startDate = CRM_Utils_Date::customFormat(CRM_Utils_Array::value('start_date', $formatted), '%Y-%m-%d');
 385       $endDate = CRM_Utils_Date::customFormat(CRM_Utils_Array::value('end_date', $formatted), '%Y-%m-%d');
 386       $joinDate = CRM_Utils_Date::customFormat(CRM_Utils_Array::value('join_date', $formatted), '%Y-%m-%d');
 387
 388       if (!$this->isContactIDColumnPresent()) {
 389         $error = $this->checkContactDuplicate($formatValues);
 390
 391         if (CRM_Core_Error::isAPIError($error, CRM_Core_ERROR::DUPLICATE_CONTACT)) {
 392           $matchedIDs = explode(',', $error['error_message']['params'][0]);
 393           if (count($matchedIDs) > 1) {
 394             array_unshift($values, 'Multiple matching contact records detected for this row. The membership was not imported');
 395             return CRM_Import_Parser::ERROR;
 396           }
 397           else {
 398             $cid = $matchedIDs[0];
 399             $formatted['contact_id'] = $cid;
 400
 401             //fix for CRM-1924
 402             $calcDates = CRM_Member_BAO_MembershipType::getDatesForMembershipType($formatted['membership_type_id'],
 403               $joinDate,
 404               $startDate,
 405               $endDate
 406             );
 407             self::formattedDates($calcDates, $formatted);
 408
 409             //fix for CRM-3570, exclude the statuses those having is_admin = 1
 410             //now user can import is_admin if is override is true.
 411             $excludeIsAdmin = FALSE;
 412             if (empty($formatted['member_is_override'])) {
 413               $formatted['exclude_is_admin'] = $excludeIsAdmin = TRUE;
 414             }
 415             $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($startDate,
 416               $endDate,
 417               $joinDate,
 418               'now',
 419               $excludeIsAdmin,
 420               $formatted['membership_type_id'],
 421               $formatted
 422             );
 423
 424             if (empty($formatted['status_id'])) {
 425               $formatted['status_id'] = $calcStatus['id'];
 426             }
 427             elseif (empty($formatted['member_is_override'])) {
 428               if (empty($calcStatus)) {
 429                 array_unshift($values, 'Status in import row (' . $formatValues['status_id'] . ') does not match calculated status based on your configured Membership Status Rules. Record was not imported.');
 430                 return CRM_Import_Parser::ERROR;
 431               }
 432               elseif ($formatted['status_id'] != $calcStatus['id']) {
 433                 //Status Hold" is either NOT mapped or is FALSE
 434                 array_unshift($values, 'Status in import row (' . $formatValues['status_id'] . ') does not match calculated status based on your configured Membership Status Rules (' . $calcStatus['name'] . '). Record was not imported.');
 435                 return CRM_Import_Parser::ERROR;
 436               }
 437             }
 438
 439             $newMembership = civicrm_api3('membership', 'create', $formatted);
 440
 441             $this->_newMemberships[] = $newMembership['id'];
 442             return CRM_Import_Parser::VALID;
 443           }
 444         }
 445         else {
 446           // Using new Dedupe rule.
 447           $ruleParams = [
 448             'contact_type' => $this->_contactType,
 449             'used' => 'Unsupervised',
 450           ];
 451           $fieldsArray = CRM_Dedupe_BAO_Rule::dedupeRuleFields($ruleParams);
 452           $disp = '';
 453
 454           foreach ($fieldsArray as $value) {
 455             if (array_key_exists(trim($value), $params)) {
 456               $paramValue = $params[trim($value)];
 457               if (is_array($paramValue)) {
 458                 $disp .= $params[trim($value)][0][trim($value)] . " ";
 459               }
 460               else {
 461                 $disp .= $params[trim($value)] . " ";
 462               }
 463             }
 464           }
 465
 466           if (!empty($params['external_identifier'])) {
 467             if ($disp) {
 468               $disp .= "AND {$params['external_identifier']}";
 469             }
 470             else {
 471               $disp = $params['external_identifier'];
 472             }
 473           }
 474
 475           array_unshift($values, 'No matching Contact found for (' . $disp . ')');
 476           return CRM_Import_Parser::ERROR;
 477         }
 478       }
 479       else {
 480         if (!empty($formatValues['external_identifier'])) {
 481           $checkCid = new CRM_Contact_DAO_Contact();
 482           $checkCid->external_identifier = $formatValues['external_identifier'];
 483           $checkCid->find(TRUE);
 484           if ($checkCid->id != $formatted['contact_id']) {
 485             array_unshift($values, 'Mismatch of External ID:' . $formatValues['external_identifier'] . ' and Contact Id:' . $formatted['contact_id']);
 486             return CRM_Import_Parser::ERROR;
 487           }
 488         }
 489
 490         //to calculate dates
 491         $calcDates = CRM_Member_BAO_MembershipType::getDatesForMembershipType($formatted['membership_type_id'],
 492           $joinDate,
 493           $startDate,
 494           $endDate
 495         );
 496         self::formattedDates($calcDates, $formatted);
 497         //end of date calculation part
 498
 499         //fix for CRM-3570, exclude the statuses those having is_admin = 1
 500         //now user can import is_admin if is override is true.
 501         $excludeIsAdmin = FALSE;
 502         if (empty($formatted['member_is_override'])) {
 503           $formatted['exclude_is_admin'] = $excludeIsAdmin = TRUE;
 504         }
 505         $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($startDate,
 506           $endDate,
 507           $joinDate,
 508           'now',
 509           $excludeIsAdmin,
 510           $formatted['membership_type_id'],
 511           $formatted
 512         );
 513         if (empty($formatted['status_id'])) {
 514           $formatted['status_id'] = $calcStatus['id'] ?? NULL;
 515         }
 516         elseif (empty($formatted['member_is_override'])) {
 517           if (empty($calcStatus)) {
 518             array_unshift($values, 'Status in import row (' . CRM_Utils_Array::value('status_id', $formatValues) . ') does not match calculated status based on your configured Membership Status Rules. Record was not imported.');
 519             return CRM_Import_Parser::ERROR;
 520           }
 521           elseif ($formatted['status_id'] != $calcStatus['id']) {
 522             //Status Hold" is either NOT mapped or is FALSE
 523             array_unshift($values, 'Status in import row (' . CRM_Utils_Array::value('status_id', $formatValues) . ') does not match calculated status based on your configured Membership Status Rules (' . $calcStatus['name'] . '). Record was not imported.');
 524             return CRM_Import_Parser::ERROR;
 525           }
 526         }
 527
 528         $newMembership = civicrm_api3('membership', 'create', $formatted);
 529
 530         $this->_newMemberships[] = $newMembership['id'];
 531         return CRM_Import_Parser::VALID;
 532       }
 533     }
 534     catch (Exception $e) {
 535       array_unshift($values, $e->getMessage());
 536       return CRM_Import_Parser::ERROR;
 537     }
 538   }
 539
 540   /**
 541    * Get the array of successfully imported membership id's
 542    *
 543    * @return array
 544    */
 545   public function &getImportedMemberships() {
 546     return $this->_newMemberships;
 547   }
 548
 549   /**
 550    * The initializer code, called before the processing
 551    *
 552    * @return void
 553    */
 554   public function fini() {
 555   }
 556
 557   /**
 558    *  to calculate join, start and end dates
 559    *
 560    * @param array $calcDates
 561    *   Array of dates returned by getDatesForMembershipType().
 562    *
 563    * @param $formatted
 564    *
 565    */
 566   public function formattedDates($calcDates, &$formatted) {
 567     $dates = [
 568       'join_date',
 569       'start_date',
 570       'end_date',
 571     ];
 572
 573     foreach ($dates as $d) {
 574       if (isset($formatted[$d]) &&
 575         !CRM_Utils_System::isNull($formatted[$d])
 576       ) {
 577         $formatted[$d] = CRM_Utils_Date::isoToMysql($formatted[$d]);
 578       }
 579       elseif (isset($calcDates[$d])) {
 580         $formatted[$d] = CRM_Utils_Date::isoToMysql($calcDates[$d]);
 581       }
 582     }
 583   }
 584
 585   /**
 586    * @deprecated - this function formats params according to v2 standards but
 587    * need to be sure about the impact of not calling it so retaining on the import class
 588    * take the input parameter list as specified in the data model and
 589    * convert it into the same format that we use in QF and BAO object
 590    *
 591    * @param array $params
 592    *   Associative array of property name/value.
 593    *                             pairs to insert in new contact.
 594    * @param array $values
 595    *   The reformatted properties that we can use internally.
 596    *
 597    * @param array|bool $create Is the formatted Values array going to
 598    *                             be used for CRM_Member_BAO_Membership:create()
 599    *
 600    * @throws Exception
 601    * @return array|error
 602    */
 603   public function membership_format_params($params, &$values, $create = FALSE) {
 604     require_once 'api/v3/utils.php';
 605     $fields = CRM_Member_DAO_Membership::fields();
 606     _civicrm_api3_store_values($fields, $params, $values);
 607
 608     $customFields = CRM_Core_BAO_CustomField::getFields('Membership');
 609
 610     foreach ($params as $key => $value) {
 611
 612       //Handling Custom Data
 613       if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
 614         $values[$key] = $value;
 615         $type = $customFields[$customFieldID]['html_type'];
 616         if (CRM_Core_BAO_CustomField::isSerialized($customFields[$customFieldID])) {
 617           $values[$key] = self::unserializeCustomValue($customFieldID, $value, $type);
 618         }
 619       }
 620
 621       switch ($key) {
 622         case 'membership_contact_id':
 623           if (!CRM_Utils_Rule::integer($value)) {
 624             throw new Exception("contact_id not valid: $value");
 625           }
 626           $dao = new CRM_Core_DAO();
 627           $qParams = [];
 628           $svq = $dao->singleValueQuery("SELECT id FROM civicrm_contact WHERE id = $value",
 629             $qParams
 630           );
 631           if (!$svq) {
 632             throw new Exception("Invalid Contact ID: There is no contact record with contact_id = $value.");
 633           }
 634           $values['contact_id'] = $values['membership_contact_id'];
 635           unset($values['membership_contact_id']);
 636           break;
 637
 638         case 'membership_type_id':
 639           if (!array_key_exists($value, CRM_Member_PseudoConstant::membershipType())) {
 640             throw new Exception('Invalid Membership Type Id');
 641           }
 642           $values[$key] = $value;
 643           break;
 644
 645         case 'membership_type':
 646           $membershipTypeId = CRM_Utils_Array::key(ucfirst($value),
 647             CRM_Member_PseudoConstant::membershipType()
 648           );
 649           if ($membershipTypeId) {
 650             if (!empty($values['membership_type_id']) &&
 651               $membershipTypeId != $values['membership_type_id']
 652             ) {
 653               throw new Exception('Mismatched membership Type and Membership Type Id');
 654             }
 655           }
 656           else {
 657             throw new Exception('Invalid Membership Type');
 658           }
 659           $values['membership_type_id'] = $membershipTypeId;
 660           break;
 661
 662         default:
 663           break;
 664       }
 665     }
 666
 667     _civicrm_api3_custom_format_params($params, $values, 'Membership');
 668
 669     if ($create) {
 670       // CRM_Member_BAO_Membership::create() handles membership_start_date, membership_join_date,
 671       // membership_end_date and membership_source. So, if $values contains
 672       // membership_start_date, membership_end_date, membership_join_date or membership_source,
 673       // convert it to start_date, end_date, join_date or source
 674       $changes = [
 675         'membership_join_date' => 'join_date',
 676         'membership_start_date' => 'start_date',
 677         'membership_end_date' => 'end_date',
 678         'membership_source' => 'source',
 679       ];
 680
 681       foreach ($changes as $orgVal => $changeVal) {
 682         if (isset($values[$orgVal])) {
 683           $values[$changeVal] = $values[$orgVal];
 684           unset($values[$orgVal]);
 685         }
 686       }
 687     }
 688
 689     return NULL;
 690   }
 691
 692   /**
 693    * Is the contact ID mapped.
 694    *
 695    * @return bool
 696    */
 697   protected function isContactIDColumnPresent(): bool {
 698     return in_array('membership_contact_id', $this->_mapperKeys, TRUE);
 699   }
 700
 701 }