Civi/Test/Api3TestTrait.php

   1 <?php
   2
   3 namespace Civi\Test;
   4
   5 use Civi\API\Exception\NotImplementedException;
   6
   7 /**
   8  * Class Api3TestTrait
   9  * @package Civi\Test
  10  *
  11  * This trait defines a number of helper functions for testing APIv3. Commonly
  12  * used helpers include `callAPISuccess()`, `callAPIFailure()`,
  13  * `assertAPISuccess()`, and `assertAPIFailure()`.
  14  *
  15  * This trait is intended for use with PHPUnit-based test cases.
  16  */
  17 trait Api3TestTrait {
  18
  19   /**
  20    * Get the api versions to test.
  21    *
  22    * @return array
  23    */
  24   public function versionThreeAndFour() {
  25     $r = [[3]];
  26     global $civicrm_root;
  27     if (file_exists("$civicrm_root/Civi/Api4") || file_exists("$civicrm_root/ext/api4")) {
  28       $r[] = [4];
  29     }
  30     return $r;
  31   }
  32
  33   /**
  34    * Api version - easier to override than just a define
  35    * @var int
  36    */
  37   protected $_apiversion = 3;
  38
  39   /**
  40    * Check that api returned 'is_error' => 1
  41    * else provide full message
  42    * @param array $result
  43    * @param $expected
  44    * @param array $valuesToExclude
  45    * @param string $prefix
  46    *   Extra test to add to message.
  47    */
  48   public function assertAPIArrayComparison($result, $expected, $valuesToExclude = [], $prefix = '') {
  49     $valuesToExclude = array_merge($valuesToExclude, ['debug', 'xdebug', 'sequential']);
  50     foreach ($valuesToExclude as $value) {
  51       if (isset($result[$value])) {
  52         unset($result[$value]);
  53       }
  54       if (isset($expected[$value])) {
  55         unset($expected[$value]);
  56       }
  57     }
  58     $this->assertEquals($result, $expected, "api result array comparison failed " . $prefix . print_r($result, TRUE) . ' was compared to ' . print_r($expected, TRUE));
  59   }
  60
  61   /**
  62    * Check that a deleted item has been deleted.
  63    *
  64    * @param $entity
  65    * @param $id
  66    */
  67   public function assertAPIDeleted($entity, $id) {
  68     $this->callAPISuccess($entity, 'getcount', ['id' => $id], 0);
  69   }
  70
  71   /**
  72    * Check that api returned 'is_error' => 1.
  73    *
  74    * @param array $apiResult
  75    *   Api result.
  76    * @param string $prefix
  77    *   Extra test to add to message.
  78    * @param null $expectedError
  79    */
  80   public function assertAPIFailure($apiResult, $prefix = '', $expectedError = NULL) {
  81     if (!empty($prefix)) {
  82       $prefix .= ': ';
  83     }
  84     if ($expectedError && !empty($apiResult['is_error'])) {
  85       $this->assertContains($expectedError, $apiResult['error_message'], 'api error message not as expected' . $prefix);
  86     }
  87     $this->assertEquals(1, $apiResult['is_error'], "api call should have failed but it succeeded " . $prefix . (print_r($apiResult, TRUE)));
  88     $this->assertNotEmpty($apiResult['error_message']);
  89   }
  90
  91   /**
  92    * Check that api returned 'is_error' => 0.
  93    *
  94    * @param array $apiResult
  95    *   Api result.
  96    * @param string $prefix
  97    *   Extra test to add to message.
  98    */
  99   public function assertAPISuccess($apiResult, $prefix = '') {
 100     if (!empty($prefix)) {
 101       $prefix .= ': ';
 102     }
 103     $errorMessage = empty($apiResult['error_message']) ? '' : " " . $apiResult['error_message'];
 104
 105     if (!empty($apiResult['debug_information'])) {
 106       $errorMessage .= "\n " . print_r($apiResult['debug_information'], TRUE);
 107     }
 108     if (!empty($apiResult['trace'])) {
 109       $errorMessage .= "\n" . print_r($apiResult['trace'], TRUE);
 110     }
 111     $this->assertEmpty(\CRM_Utils_Array::value('is_error', $apiResult), $prefix . $errorMessage);
 112   }
 113
 114   /**
 115    * This function exists to wrap api functions.
 116    * so we can ensure they fail where expected & throw exceptions without litterering the test with checks
 117    * @param string $entity
 118    * @param string $action
 119    * @param array $params
 120    * @param string $expectedErrorMessage
 121    *   Error.
 122    * @param null $extraOutput
 123    * @return array|int
 124    */
 125   public function callAPIFailure($entity, $action, $params, $expectedErrorMessage = NULL, $extraOutput = NULL) {
 126     if (is_array($params)) {
 127       $params += [
 128         'version' => $this->_apiversion,
 129       ];
 130     }
 131     $result = $this->civicrm_api($entity, $action, $params);
 132     $this->assertAPIFailure($result, "We expected a failure for $entity $action but got a success", $expectedErrorMessage);
 133     return $result;
 134   }
 135
 136   /**
 137    * wrap api functions.
 138    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 139    *
 140    * @param string $entity
 141    * @param string $action
 142    * @param array $params
 143    * @param mixed $checkAgainst
 144    *   Optional value to check result against, implemented for getvalue,.
 145    *   getcount, getsingle. Note that for getvalue the type is checked rather than the value
 146    *   for getsingle the array is compared against an array passed in - the id is not compared (for
 147    *   better or worse )
 148    *
 149    * @return array|int
 150    *
 151    * @throws \CRM_Core_Exception
 152    */
 153   public function callAPISuccess($entity, $action, $params = [], $checkAgainst = NULL) {
 154     $params = array_merge([
 155       'version' => $this->_apiversion,
 156       'debug' => 1,
 157     ],
 158       $params
 159     );
 160     switch (strtolower($action)) {
 161       case 'getvalue':
 162         return $this->callAPISuccessGetValue($entity, $params, $checkAgainst);
 163
 164       case 'getsingle':
 165         return $this->callAPISuccessGetSingle($entity, $params, $checkAgainst);
 166
 167       case 'getcount':
 168         return $this->callAPISuccessGetCount($entity, $params, $checkAgainst);
 169     }
 170     $result = $this->civicrm_api($entity, $action, $params);
 171     $this->assertAPISuccess($result, "Failure in api call for $entity $action");
 172     return $result;
 173   }
 174
 175   /**
 176    * This function exists to wrap api getValue function & check the result
 177    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 178    * There is a type check in this
 179    *
 180    * @param string $entity
 181    * @param array $params
 182    * @param int $count
 183    *
 184    * @throws \CRM_Core_Exception
 185    *
 186    * @return array|int
 187    */
 188   public function callAPISuccessGetCount($entity, $params, $count = NULL) {
 189     $params += [
 190       'version' => $this->_apiversion,
 191       'debug' => 1,
 192     ];
 193     $result = $this->civicrm_api($entity, 'getcount', $params);
 194     if (!is_int($result) || !empty($result['is_error']) || isset($result['values'])) {
 195       throw new \CRM_Core_Exception('Invalid getcount result : ' . print_r($result, TRUE) . " type :" . gettype($result));
 196     }
 197     if (is_int($count)) {
 198       $this->assertEquals($count, $result, "incorrect count returned from $entity getcount");
 199     }
 200     return $result;
 201   }
 202
 203   /**
 204    * This function exists to wrap api getsingle function & check the result
 205    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 206    *
 207    * @param string $entity
 208    * @param array $params
 209    * @param array $checkAgainst
 210    *   Array to compare result against.
 211    *   - boolean
 212    *   - integer
 213    *   - double
 214    *   - string
 215    *   - array
 216    *   - object
 217    *
 218    * @throws \CRM_Core_Exception
 219    *
 220    * @return array|int
 221    */
 222   public function callAPISuccessGetSingle($entity, $params, $checkAgainst = NULL) {
 223     $params += [
 224       'version' => $this->_apiversion,
 225     ];
 226     $result = $this->civicrm_api($entity, 'getsingle', $params);
 227     if (!is_array($result) || !empty($result['is_error']) || isset($result['values'])) {
 228       $unfilteredResult = $this->civicrm_api($entity, 'get', ['version' => $this->_apiversion]);
 229       throw new \CRM_Core_Exception(
 230         'Invalid getsingle result' . print_r($result, TRUE)
 231         . "\n entity: $entity . \n params \n " . print_r($params, TRUE)
 232         . "\n entities retrieved with blank params \n" . print_r($unfilteredResult, TRUE)
 233       );
 234     }
 235     if ($checkAgainst) {
 236       // @todo - have gone with the fn that unsets id? should we check id?
 237       $this->checkArrayEquals($result, $checkAgainst);
 238     }
 239     return $result;
 240   }
 241
 242   /**
 243    * This function exists to wrap api getValue function & check the result
 244    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 245    * There is a type check in this
 246    *
 247    * @param string $entity
 248    * @param array $params
 249    * @param string $type
 250    *   Per http://php.net/manual/en/function.gettype.php possible types.
 251    *   - boolean
 252    *   - integer
 253    *   - double
 254    *   - string
 255    *   - array
 256    *   - object
 257    *
 258    * @return array|int
 259    * @throws \CRM_Core_Exception
 260    */
 261   public function callAPISuccessGetValue($entity, $params, $type = NULL) {
 262     $params += [
 263       'version' => $this->_apiversion,
 264       'debug' => 1,
 265     ];
 266     $result = $this->civicrm_api($entity, 'getvalue', $params);
 267     if (is_array($result) && (!empty($result['is_error']) || isset($result['values']))) {
 268       throw new \CRM_Core_Exception('Invalid getvalue result' . print_r($result, TRUE));
 269     }
 270     if ($type) {
 271       if ($type === 'integer') {
 272         // api seems to return integers as strings
 273         $this->assertTrue(is_numeric($result), "expected a numeric value but got " . print_r($result, 1));
 274       }
 275       else {
 276         $this->assertType($type, $result, "returned result should have been of type $type but was ");
 277       }
 278     }
 279     return $result;
 280   }
 281
 282   /**
 283    * A stub for the API interface. This can be overriden by subclasses to change how the API is called.
 284    *
 285    * @param $entity
 286    * @param $action
 287    * @param array $params
 288    * @return array|int
 289    */
 290   public function civicrm_api($entity, $action, $params = []) {
 291     if (\CRM_Utils_Array::value('version', $params) == 4) {
 292       return $this->runApi4Legacy($entity, $action, $params);
 293     }
 294     return civicrm_api($entity, $action, $params);
 295   }
 296
 297   /**
 298    * Emulate v3 syntax so we can run api3 tests on v4
 299    *
 300    * @param $v3Entity
 301    * @param $v3Action
 302    * @param array $v3Params
 303    * @return array|int
 304    * @throws \API_Exception
 305    * @throws \CiviCRM_API3_Exception
 306    * @throws \Exception
 307    */
 308   public function runApi4Legacy($v3Entity, $v3Action, $v3Params = []) {
 309     $v4Entity = self::convertEntityNameToApi4($v3Entity);
 310     $v4Action = $v3Action = strtolower($v3Action);
 311     $v4Params = ['checkPermissions' => isset($v3Params['check_permissions']) ? (bool) $v3Params['check_permissions'] : FALSE];
 312     $sequential = !empty($v3Params['sequential']);
 313     $options = \_civicrm_api3_get_options_from_params($v3Params, in_array($v4Entity, ['Contact', 'Participant', 'Event', 'Group', 'Contribution', 'Membership']));
 314     $indexBy = in_array($v3Action, ['get', 'create', 'replace']) && !$sequential ? 'id' : NULL;
 315     $onlyId = !empty($v3Params['format.only_id']);
 316     $onlySuccess = !empty($v3Params['format.is_success']);
 317     if (!empty($v3Params['filters']['is_current']) || !empty($v3Params['isCurrent'])) {
 318       $v4Params['current'] = TRUE;
 319     }
 320     $language = !empty($v3Params['options']['language']) ? $v3Params['options']['language'] : \CRM_Utils_Array::value('option.language', $v3Params);
 321     if ($language) {
 322       $v4Params['language'] = $language;
 323     }
 324     $toRemove = ['option.', 'return', 'api.', 'format.'];
 325     $chains = $joins = $custom = [];
 326     foreach ($v3Params as $key => $val) {
 327       foreach ($toRemove as $remove) {
 328         if (strpos($key, $remove) === 0) {
 329           if ($remove == 'api.') {
 330             $chains[$key] = $val;
 331           }
 332           unset($v3Params[$key]);
 333         }
 334       }
 335     }
 336
 337     $v3Fields = civicrm_api3($v3Entity, 'getfields', ['action' => $v3Action])['values'];
 338
 339     // Fix 'null'
 340     foreach ($v3Params as $key => $val) {
 341       if ($val === 'null') {
 342         $v3Params[$key] = NULL;
 343       }
 344     }
 345
 346     if ($v4Entity == 'Setting') {
 347       $indexBy = NULL;
 348       $v4Params['domainId'] = \CRM_Utils_Array::value('domain_id', $v3Params);
 349       if ($v3Action == 'getfields') {
 350         if (!empty($v3Params['name'])) {
 351           $v3Params['filters']['name'] = $v3Params['name'];
 352         }
 353         foreach (\CRM_Utils_Array::value('filters', $v3Params, []) as $filter => $val) {
 354           $v4Params['where'][] = [$filter, '=', $val];
 355         }
 356       }
 357       if ($v3Action == 'create') {
 358         $v4Action = 'set';
 359       }
 360       if ($v3Action == 'revert') {
 361         $v4Params['select'] = (array) $v3Params['name'];
 362       }
 363       if ($v3Action == 'getvalue') {
 364         $options['return'] = [$v3Params['name'] => 1];
 365         $v3Params = [];
 366       }
 367       \CRM_Utils_Array::remove($v3Params, 'domain_id', 'name');
 368     }
 369
 370     \CRM_Utils_Array::remove($v3Params, 'options', 'debug', 'version', 'sort', 'offset', 'rowCount', 'check_permissions', 'sequential', 'filters', 'isCurrent');
 371
 372     // Work around ugly hack in v3 Domain api
 373     if ($v4Entity == 'Domain') {
 374       $v3Fields['version'] = ['name' => 'version', 'api.aliases' => ['domain_version']];
 375       unset($v3Fields['domain_version']);
 376     }
 377
 378     foreach ($v3Fields as $name => $field) {
 379       // Resolve v3 aliases
 380       foreach (\CRM_Utils_Array::value('api.aliases', $field, []) as $alias) {
 381         if (isset($v3Params[$alias])) {
 382           $v3Params[$field['name']] = $v3Params[$alias];
 383           unset($v3Params[$alias]);
 384         }
 385       }
 386       // Convert custom field names
 387       if (strpos($name, 'custom_') === 0 && is_numeric($name[7])) {
 388         // Strictly speaking, using titles instead of names is incorrect, but it works for
 389         // unit tests where names and titles are identical and saves an extra db lookup.
 390         $custom[$field['groupTitle']][$field['title']] = $name;
 391         $v4FieldName = $field['groupTitle'] . '.' . $field['title'];
 392         if (isset($v3Params[$name])) {
 393           $v3Params[$v4FieldName] = $v3Params[$name];
 394           unset($v3Params[$name]);
 395         }
 396         if (isset($options['return'][$name])) {
 397           $options['return'][$v4FieldName] = 1;
 398           unset($options['return'][$name]);
 399         }
 400       }
 401     }
 402
 403     switch ($v3Action) {
 404       case 'getcount':
 405         $v4Params['select'] = ['row_count'];
 406         // No break - keep processing as get
 407       case 'getsingle':
 408       case 'getvalue':
 409         $v4Action = 'get';
 410         // No break - keep processing as get
 411       case 'get':
 412         if ($options['return'] && $v3Action !== 'getcount') {
 413           $v4Params['select'] = array_keys($options['return']);
 414           // Ensure id field is returned as v3 always expects it
 415           if ($v4Entity != 'Setting' && !in_array('id', $v4Params['select'])) {
 416             $v4Params['select'][] = 'id';
 417           }
 418           // Convert join syntax
 419           foreach ($v4Params['select'] as &$select) {
 420             if (strstr($select, '_id.')) {
 421               $joins[$select] = explode('.', str_replace('_id.', '.', $select));
 422               $select = str_replace('_id.', '.', $select);
 423             }
 424           }
 425         }
 426         if ($options['limit'] && $v4Entity != 'Setting') {
 427           $v4Params['limit'] = $options['limit'];
 428         }
 429         if ($options['offset']) {
 430           $v4Params['offset'] = $options['offset'];
 431         }
 432         if ($options['sort']) {
 433           foreach (explode(',', $options['sort']) as $sort) {
 434             list($sortField, $sortDir) = array_pad(explode(' ', trim($sort)), 2, 'ASC');
 435             $v4Params['orderBy'][$sortField] = $sortDir;
 436           }
 437         }
 438         break;
 439
 440       case 'replace':
 441         if (empty($v3Params['values'])) {
 442           $v4Action = 'delete';
 443         }
 444         else {
 445           $v4Params['records'] = $v3Params['values'];
 446         }
 447         unset($v3Params['values']);
 448         break;
 449
 450       case 'create':
 451       case 'update':
 452         if (!empty($v3Params['id'])) {
 453           $v4Action = 'update';
 454           $v4Params['where'][] = ['id', '=', $v3Params['id']];
 455         }
 456
 457         $v4Params['values'] = $v3Params;
 458         unset($v4Params['values']['id']);
 459         break;
 460
 461       case 'delete':
 462         if (!empty($v3Params['id'])) {
 463           $v4Params['where'][] = ['id', '=', $v3Params['id']];
 464         }
 465         break;
 466
 467       case 'getoptions':
 468         $indexBy = 0;
 469         $v4Action = 'getFields';
 470         $v4Params += [
 471           'where' => [['name', '=', $v3Params['field']]],
 472           'loadOptions' => TRUE,
 473         ];
 474         break;
 475
 476       case 'getfields':
 477         $v4Action = 'getFields';
 478         if (!empty($v3Params['action']) || !empty($v3Params['api_action'])) {
 479           $v4Params['action'] = !empty($v3Params['action']) ? $v3Params['action'] : $v3Params['api_action'];
 480         }
 481         $indexBy = !$sequential ? 'name' : NULL;
 482         break;
 483     }
 484
 485     // Ensure this api4 entity/action exists
 486     try {
 487       $actionInfo = \civicrm_api4($v4Entity, 'getActions', ['checkPermissions' => FALSE, 'where' => [['name', '=', $v4Action]]]);
 488     }
 489     catch (NotImplementedException $e) {
 490       // For now we'll mark the test incomplete if a v4 entity doesn't exit yet
 491       $this->markTestIncomplete($e->getMessage());
 492     }
 493     if (!isset($actionInfo[0])) {
 494       throw new \Exception("Api4 $v4Entity $v4Action does not exist.");
 495     }
 496
 497     // Migrate special params like fix_address
 498     foreach ($actionInfo[0]['params'] as $v4ParamName => $paramInfo) {
 499       // camelCase in api4, lower_case in api3
 500       $v3ParamName = strtolower(preg_replace('/(?=[A-Z])/', '_$0', $v4ParamName));
 501       if (isset($v3Params[$v3ParamName])) {
 502         $v4Params[$v4ParamName] = $v3Params[$v3ParamName];
 503         unset($v3Params[$v3ParamName]);
 504         if ($paramInfo['type'][0] == 'bool') {
 505           $v4Params[$v4ParamName] = (bool) $v4Params[$v4ParamName];
 506         }
 507       }
 508     }
 509
 510     // Build where clause for 'getcount', 'getsingle', 'getvalue', 'get' & 'replace'
 511     if ($v4Action == 'get' || $v3Action == 'replace') {
 512       foreach ($v3Params as $key => $val) {
 513         $op = '=';
 514         if (is_array($val) && count($val) == 1 && array_intersect_key($val, array_flip(\CRM_Core_DAO::acceptedSQLOperators()))) {
 515           foreach ($val as $op => $newVal) {
 516             $val = $newVal;
 517           }
 518         }
 519         $v4Params['where'][] = [$key, $op, $val];
 520       }
 521     }
 522
 523     try {
 524       $result = \civicrm_api4($v4Entity, $v4Action, $v4Params, $indexBy);
 525     }
 526     catch (\Exception $e) {
 527       return $onlySuccess ? 0 : [
 528         'is_error' => 1,
 529         'error_message' => $e->getMessage(),
 530         'version' => 4,
 531       ];
 532     }
 533
 534     if (($v3Action == 'getsingle' || $v3Action == 'getvalue') && count($result) != 1) {
 535       return $onlySuccess ? 0 : [
 536         'is_error' => 1,
 537         'error_message' => "Expected one $v4Entity but found " . count($result),
 538         'count' => count($result),
 539       ];
 540     }
 541
 542     if ($onlySuccess) {
 543       return 1;
 544     }
 545
 546     if ($v3Action == 'getcount') {
 547       return $result->count();
 548     }
 549
 550     if ($onlyId) {
 551       return $result->first()['id'];
 552     }
 553
 554     if ($v3Action == 'getvalue' && $v4Entity == 'Setting') {
 555       return \CRM_Utils_Array::value('value', $result->first());
 556     }
 557
 558     if ($v3Action == 'getvalue') {
 559       return \CRM_Utils_Array::value(array_keys($options['return'])[0], $result->first());
 560     }
 561
 562     // Mimic api3 behavior when using 'replace' action to delete all
 563     if ($v3Action == 'replace' && $v4Action == 'delete') {
 564       $result->exchangeArray([]);
 565     }
 566
 567     if ($v3Action == 'getoptions') {
 568       return [
 569         'is_error' => 0,
 570         'count' => $result['options'] ? count($result['options']) : 0,
 571         'values' => $result['options'] ?: [],
 572         'version' => 4,
 573       ];
 574     }
 575
 576     // Emulate the weird return format of api3 settings
 577     if (($v3Action == 'get' || $v3Action == 'create') && $v4Entity == 'Setting') {
 578       $settings = [];
 579       foreach ($result as $item) {
 580         $settings[$item['domain_id']][$item['name']] = $item['value'];
 581       }
 582       $result->exchangeArray($sequential ? array_values($settings) : $settings);
 583     }
 584
 585     foreach ($result as $index => $row) {
 586       // Run chains
 587       foreach ($chains as $key => $params) {
 588         $result[$index][$key] = $this->runApi4LegacyChain($key, $params, $v4Entity, $row, $sequential);
 589       }
 590       // Convert join format
 591       foreach ($joins as $api3Key => $api4Path) {
 592         $result[$index][$api3Key] = \CRM_Utils_Array::pathGet($result[$index], $api4Path);
 593       }
 594       // Resolve custom field names
 595       foreach ($custom as $group => $fields) {
 596         foreach ($fields as $field => $v3FieldName) {
 597           if (isset($row["$group.$field"])) {
 598             $result[$index][$v3FieldName] = $row["$group.$field"];
 599             unset($result[$index]["$group.$field"]);
 600           }
 601         }
 602       }
 603     }
 604
 605     if ($v3Action == 'getsingle') {
 606       return $result->first();
 607     }
 608
 609     return [
 610       'is_error' => 0,
 611       'version' => 4,
 612       'count' => count($result),
 613       'values' => (array) $result,
 614       'id' => is_object($result) && count($result) == 1 ? \CRM_Utils_Array::value('id', $result->first()) : NULL,
 615     ];
 616   }
 617
 618   /**
 619    * @param string $key
 620    * @param mixed $params
 621    * @param string $mainEntity
 622    * @param array $result
 623    * @param bool $sequential
 624    * @return array
 625    * @throws \API_Exception
 626    */
 627   protected function runApi4LegacyChain($key, $params, $mainEntity, $result, $sequential) {
 628     // Handle an array of multiple calls using recursion
 629     if (is_array($params) && isset($params[0]) && is_array($params[0])) {
 630       $results = [];
 631       foreach ($params as $chain) {
 632         $results[] = $this->runApi4LegacyChain($key, $chain, $mainEntity, $result, $sequential);
 633       }
 634       return $results;
 635     }
 636
 637     // Handle single api call
 638     list(, $chainEntity, $chainAction) = explode('.', $key);
 639     $lcChainEntity = \_civicrm_api_get_entity_name_from_camel($chainEntity);
 640     $chainEntity = self::convertEntityNameToApi4($chainEntity);
 641     $lcMainEntity = \_civicrm_api_get_entity_name_from_camel($mainEntity);
 642     $params = is_array($params) ? $params : [];
 643
 644     // Api3 expects this to be inherited
 645     $params += ['sequential' => $sequential];
 646
 647     // Replace $value.field_name
 648     foreach ($params as $name => $param) {
 649       if (is_string($param) && strpos($param, '$value.') === 0) {
 650         $param = substr($param, 7);
 651         $params[$name] = \CRM_Utils_Array::value($param, $result);
 652       }
 653     }
 654
 655     try {
 656       $getFields = civicrm_api4($chainEntity, 'getFields', ['select' => ['name']], 'name');
 657     }
 658     catch (NotImplementedException $e) {
 659       $this->markTestIncomplete($e->getMessage());
 660     }
 661
 662     // Emulate the string-fu guesswork that api3 does
 663     if ($chainEntity == $mainEntity && empty($params['id']) &&  !empty($result['id'])) {
 664       $params['id'] = $result['id'];
 665     }
 666     elseif (empty($params['id']) && !empty($result[$lcChainEntity . '_id'])) {
 667       $params['id'] = $result[$lcChainEntity . '_id'];
 668     }
 669     elseif (!empty($result['id']) && isset($getFields[$lcMainEntity . '_id']) && empty($params[$lcMainEntity . '_id'])) {
 670       $params[$lcMainEntity . '_id'] = $result['id'];
 671     }
 672     return $this->runApi4Legacy($chainEntity, $chainAction, $params);
 673   }
 674
 675   /**
 676    * Fix the naming differences between api3 & api4 entities.
 677    *
 678    * @param string $legacyName
 679    * @return string
 680    */
 681   public static function convertEntityNameToApi4($legacyName) {
 682     $api4Name = \CRM_Utils_String::convertStringToCamel($legacyName);
 683     $map = [
 684       'Im' => 'IM',
 685       'Acl' => 'ACL',
 686     ];
 687     return \CRM_Utils_Array::value($api4Name, $map, $api4Name);
 688   }
 689
 690 }