CRM/Core/BAO/CustomValueTable.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   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-2014
  32  * $Id$
  33  *
  34  */
  35 class CRM_Core_BAO_CustomValueTable {
  36
  37   /**
  38    * @param array $customParams
  39    *
  40    * @throws Exception
  41    */
  42   public static function create(&$customParams) {
  43     if (empty($customParams) ||
  44       !is_array($customParams)
  45     ) {
  46       return;
  47     }
  48
  49     foreach ($customParams as $tableName => $tables) {
  50       foreach ($tables as $index => $fields) {
  51         $sqlOP      = NULL;
  52         $hookID     = NULL;
  53         $hookOP     = NULL;
  54         $entityID   = NULL;
  55         $isMultiple = FALSE;
  56         $set        = array();
  57         $params     = array();
  58         $count      = 1;
  59         foreach ($fields as $field) {
  60           if (!$sqlOP) {
  61             $entityID   = $field['entity_id'];
  62             $hookID     = $field['custom_group_id'];
  63             $isMultiple = $field['is_multiple'];
  64             if (array_key_exists('id', $field)) {
  65               $sqlOP          = "UPDATE $tableName ";
  66               $where          = " WHERE  id = %{$count}";
  67               $params[$count] = array($field['id'], 'Integer');
  68               $count++;
  69               $hookOP = 'edit';
  70             }
  71             else {
  72               $sqlOP  = "INSERT INTO $tableName ";
  73               $where  = NULL;
  74               $hookOP = 'create';
  75             }
  76           }
  77
  78           // fix the value before we store it
  79           $value = $field['value'];
  80           $type = $field['type'];
  81           switch ($type) {
  82             case 'StateProvince':
  83               $type = 'Integer';
  84               if (is_array($value)) {
  85                 $value = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR, $value) . CRM_Core_DAO::VALUE_SEPARATOR;
  86                 $type = 'String';
  87               }
  88               elseif (!is_numeric($value)) {
  89                 //fix for multi select state, CRM-3437
  90                 $mulValues = explode(',', $value);
  91                 $validStates = array();
  92                 foreach ($mulValues as $key => $stateVal) {
  93                   $states = array();
  94                   $states['state_province'] = trim($stateVal);
  95
  96                   CRM_Utils_Array::lookupValue($states, 'state_province',
  97                     CRM_Core_PseudoConstant::stateProvince(), TRUE
  98                   );
  99                   if (empty($states['state_province_id'])) {
 100                     CRM_Utils_Array::lookupValue($states, 'state_province',
 101                       CRM_Core_PseudoConstant::stateProvinceAbbreviation(), TRUE
 102                     );
 103                   }
 104                   $validStates[] = $states['state_province_id'];
 105                 }
 106                 $value = implode(CRM_Core_DAO::VALUE_SEPARATOR,
 107                   $validStates
 108                 );
 109                 $type = 'String';
 110               }
 111               elseif (!$value) {
 112                 // CRM-3415
 113                 // using type of timestamp allows us to sneak in a null into db
 114                 // gross but effective hack
 115                 $value = NULL;
 116                 $type = 'Timestamp';
 117               }
 118               break;
 119
 120             case 'Country':
 121               $type = 'Integer';
 122               if (is_array($value)) {
 123                 $value = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR, $value) . CRM_Core_DAO::VALUE_SEPARATOR;
 124                 $type = 'String';
 125               }
 126               elseif (!is_numeric($value)) {
 127                 //fix for multi select country, CRM-3437
 128                 $mulValues = explode(',', $value);
 129                 $validCountries = array();
 130                 foreach ($mulValues as $key => $countryVal) {
 131                   $countries = array();
 132                   $countries['country'] = trim($countryVal);
 133                   CRM_Utils_Array::lookupValue($countries, 'country',
 134                     CRM_Core_PseudoConstant::country(), TRUE
 135                   );
 136                   if (empty($countries['country_id'])) {
 137                     CRM_Utils_Array::lookupValue($countries, 'country',
 138                       CRM_Core_PseudoConstant::countryIsoCode(), TRUE
 139                     );
 140                   }
 141                   $validCountries[] = $countries['country_id'];
 142                 }
 143                 $value = implode(CRM_Core_DAO::VALUE_SEPARATOR,
 144                   $validCountries
 145                 );
 146                 $type = 'String';
 147               }
 148               elseif (!$value) {
 149                 // CRM-3415
 150                 // using type of timestamp allows us to sneak in a null into db
 151                 // gross but effective hack
 152                 $value = NULL;
 153                 $type = 'Timestamp';
 154               }
 155               break;
 156
 157             case 'File':
 158               if (!$field['file_id']) {
 159                 CRM_Core_Error::fatal();
 160               }
 161
 162               // need to add/update civicrm_entity_file
 163               $entityFileDAO = new CRM_Core_DAO_EntityFile();
 164               $entityFileDAO->file_id = $field['file_id'];
 165               $entityFileDAO->find(TRUE);
 166
 167               $entityFileDAO->entity_table = $field['table_name'];
 168               $entityFileDAO->entity_id = $field['entity_id'];
 169               $entityFileDAO->file_id = $field['file_id'];
 170               $entityFileDAO->save();
 171               $entityFileDAO->free();
 172               $value = $field['file_id'];
 173               $type = 'String';
 174               break;
 175
 176             case 'Date':
 177               $value = CRM_Utils_Date::isoToMysql($value);
 178               break;
 179
 180             case 'Int':
 181               if (is_numeric($value)) {
 182                 $type = 'Integer';
 183               }
 184               else {
 185                 $type = 'Timestamp';
 186               }
 187               break;
 188
 189             case 'ContactReference':
 190               if ($value == NULL) {
 191                 $type = 'Timestamp';
 192               }
 193               else {
 194                 $type = 'Integer';
 195               }
 196               break;
 197
 198             case 'RichTextEditor':
 199               $type = 'String';
 200               break;
 201
 202             case 'Boolean':
 203               //fix for CRM-3290
 204               $value = CRM_Utils_String::strtoboolstr($value);
 205               if ($value === FALSE) {
 206                 $type = 'Timestamp';
 207               }
 208               break;
 209
 210             default:
 211               break;
 212           }
 213           $set[$field['column_name']] = "%{$count}";
 214           $params[$count] = array($value, $type);
 215           $count++;
 216         }
 217
 218         if (!empty($set)) {
 219           $setClause = array();
 220           foreach ($set as $n => $v) {
 221             $setClause[] = "$n = $v";
 222           }
 223           $setClause = implode(',', $setClause);
 224           if (!$where) {
 225             // do this only for insert
 226             $set['entity_id'] = "%{$count}";
 227             $params[$count] = array($entityID, 'Integer');
 228             $count++;
 229
 230             $fieldNames  = implode(',', array_keys($set));
 231             $fieldValues = implode(',', array_values($set));
 232             $query       = "$sqlOP ( $fieldNames ) VALUES ( $fieldValues )";
 233             // for multiple values we dont do on duplicate key update
 234             if (!$isMultiple) {
 235               $query .= " ON DUPLICATE KEY UPDATE $setClause";
 236             }
 237           }
 238           else {
 239             $query = "$sqlOP SET $setClause $where";
 240           }
 241           $dao = CRM_Core_DAO::executeQuery($query, $params);
 242
 243           CRM_Utils_Hook::custom($hookOP,
 244             $hookID,
 245             $entityID,
 246             $fields
 247           );
 248         }
 249       }
 250     }
 251   }
 252
 253   /**
 254    * Given a field return the mysql data type associated with it
 255    *
 256    * @param string $type
 257    *   The civicrm type string.
 258    *
 259    * @param int $maxLength
 260    *
 261    * @return the mysql data store placeholder
 262    * @static
 263    */
 264   public static function fieldToSQLType($type, $maxLength = 255) {
 265     if (!isset($maxLength) ||
 266       !is_numeric($maxLength) ||
 267       $maxLength <= 0
 268     ) {
 269       $maxLength = 255;
 270     }
 271
 272     switch ($type) {
 273       case 'String':
 274       case 'Link':
 275         return "varchar($maxLength)";
 276
 277       case 'Boolean':
 278         return 'tinyint';
 279
 280       case 'Int':
 281         return 'int';
 282
 283       // the below three are FK's, and have constraints added to them
 284
 285       case 'ContactReference':
 286       case 'StateProvince':
 287       case 'Country':
 288       case 'File':
 289         return 'int unsigned';
 290
 291       case 'Float':
 292         return 'double';
 293
 294       case 'Money':
 295         return 'decimal(20,2)';
 296
 297       case 'Memo':
 298       case 'RichTextEditor':
 299         return 'text';
 300
 301       case 'Date':
 302         return 'datetime';
 303
 304       default:
 305         CRM_Core_Error::fatal();
 306     }
 307   }
 308
 309   /**
 310    * @param array $params
 311    * @param $entityTable
 312    * @param int $entityID
 313    */
 314   public static function store(&$params, $entityTable, $entityID) {
 315     $cvParams = array();
 316     foreach ($params as $fieldID => $param) {
 317       foreach ($param as $index => $customValue) {
 318         $cvParam = array(
 319           'entity_table' => $entityTable,
 320           'entity_id' => $entityID,
 321           'value' => $customValue['value'],
 322           'type' => $customValue['type'],
 323           'custom_field_id' => $customValue['custom_field_id'],
 324           'custom_group_id' => $customValue['custom_group_id'],
 325           'table_name' => $customValue['table_name'],
 326           'column_name' => $customValue['column_name'],
 327           'is_multiple' => CRM_Utils_Array::value('is_multiple', $customValue),
 328           'file_id' => $customValue['file_id'],
 329         );
 330
 331         // fix Date type to be timestamp, since that is how we store in db
 332         if ($cvParam['type'] == 'Date') {
 333           $cvParam['type'] = 'Timestamp';
 334         }
 335
 336         if (!empty($customValue['id'])) {
 337           $cvParam['id'] = $customValue['id'];
 338         }
 339         if (!array_key_exists($customValue['table_name'], $cvParams)) {
 340           $cvParams[$customValue['table_name']] = array();
 341         }
 342
 343         if (!array_key_exists($index, $cvParams[$customValue['table_name']])) {
 344           $cvParams[$customValue['table_name']][$index] = array();
 345         }
 346
 347         $cvParams[$customValue['table_name']][$index][] = $cvParam;
 348       }
 349     }
 350     if (!empty($cvParams)) {
 351       self::create($cvParams);
 352     }
 353   }
 354
 355   /**
 356    * @param array $params
 357    * @param $customFields
 358    * @param $entityTable
 359    * @param int $entityID
 360    * @param $customFieldExtends
 361    */
 362   public static function postProcess(&$params, &$customFields, $entityTable, $entityID, $customFieldExtends) {
 363     $customData = CRM_Core_BAO_CustomField::postProcess($params,
 364       $customFields,
 365       $entityID,
 366       $customFieldExtends
 367     );
 368
 369     if (!empty($customData)) {
 370       self::store($customData, $entityTable, $entityID);
 371     }
 372   }
 373
 374   /**
 375    * Return an array of all custom values associated with an entity.
 376    *
 377    * @param int $entityID
 378    *   Identification number of the entity.
 379    * @param string $entityType
 380    *   Type of entity that the entityID corresponds to, specified.
 381    *                                   as a string with format "'<EntityName>'". Comma separated
 382    *                                   list may be used to specify OR matches. Allowable values
 383    *                                   are enumerated types in civicrm_custom_group.extends field.
 384    *                                   Optional. Default value assumes entityID references a
 385    *                                   contact entity.
 386    * @param array $fieldIDs
 387    *   Optional list of fieldIDs that we want to retrieve. If this.
 388    *                                   is set the entityType is ignored
 389    *
 390    * @param bool $formatMultiRecordField
 391    *
 392    * @return array      $fields        Array of custom values for the entity with key=>value
 393    *                                   pairs specified as civicrm_custom_field.id => custom value.
 394    *                                   Empty array if no custom values found.
 395    * @static
 396    */
 397   public static function &getEntityValues($entityID, $entityType = NULL, $fieldIDs = NULL, $formatMultiRecordField = FALSE) {
 398     if (!$entityID) {
 399       // adding this here since an empty contact id could have serious repurcussions
 400       // like looping forever
 401       CRM_Core_Error::fatal('Please file an issue with the backtrace');
 402       return NULL;
 403     }
 404
 405     $cond = array();
 406     if ($entityType) {
 407       $cond[] = "cg.extends IN ( '$entityType' )";
 408     }
 409     if ($fieldIDs &&
 410       is_array($fieldIDs)
 411     ) {
 412       $fieldIDList = implode(',', $fieldIDs);
 413       $cond[] = "cf.id IN ( $fieldIDList )";
 414     }
 415     if (empty($cond)) {
 416       $cond[] = "cg.extends IN ( 'Contact', 'Individual', 'Household', 'Organization' )";
 417     }
 418     $cond = implode(' AND ', $cond);
 419
 420     // first find all the fields that extend this type of entity
 421     $query = "
 422 SELECT cg.table_name,
 423        cg.id as groupID,
 424        cg.is_multiple,
 425        cf.column_name,
 426        cf.id as fieldID,
 427        cf.data_type as fieldDataType
 428 FROM   civicrm_custom_group cg,
 429        civicrm_custom_field cf
 430 WHERE  cf.custom_group_id = cg.id
 431 AND    cg.is_active = 1
 432 AND    cf.is_active = 1
 433 AND    $cond
 434 ";
 435     $dao = CRM_Core_DAO::executeQuery($query);
 436
 437     $select = $fields = $isMultiple = array();
 438
 439     while ($dao->fetch()) {
 440       if (!array_key_exists($dao->table_name, $select)) {
 441         $fields[$dao->table_name] = array();
 442         $select[$dao->table_name] = array();
 443       }
 444       $fields[$dao->table_name][] = $dao->fieldID;
 445       $select[$dao->table_name][] = "{$dao->column_name} AS custom_{$dao->fieldID}";
 446       $isMultiple[$dao->table_name] = $dao->is_multiple ? TRUE : FALSE;
 447       $file[$dao->table_name][$dao->fieldID] = $dao->fieldDataType;
 448     }
 449
 450     $result = array();
 451     foreach ($select as $tableName => $clauses) {
 452       $query = "SELECT id, " . implode(', ', $clauses) . " FROM $tableName WHERE entity_id = $entityID";
 453       $dao = CRM_Core_DAO::executeQuery($query);
 454       while ($dao->fetch()) {
 455         foreach ($fields[$tableName] as $fieldID) {
 456           $fieldName = "custom_{$fieldID}";
 457           if ($isMultiple[$tableName]) {
 458             if ($formatMultiRecordField) {
 459               if ($file[$tableName][$fieldID] == 'File') {
 460                 if ($fileid = $dao->$fieldName) {
 461                   $fileurl = CRM_Core_BAO_File::paperIconAttachment($tableName, $entityID);
 462                   $result["{$dao->id}"]["{$fieldID}"] = $fileurl[$dao->$fieldName];
 463                 }
 464               }
 465               else {
 466                 $result["{$dao->id}"]["{$fieldID}"] = $dao->$fieldName;
 467               }
 468             }
 469             else {
 470               $result["{$fieldID}_{$dao->id}"] = $dao->$fieldName;
 471             }
 472           }
 473           else {
 474             if ($file[$tableName][$fieldID] == 'File') {
 475               if ($fileid = $dao->$fieldName) {
 476                 $fileurl = CRM_Core_BAO_File::paperIconAttachment($tableName, $entityID);
 477                 $result[$fieldID] = $fileurl[$dao->$fieldName];
 478               }
 479             }
 480             else {
 481               $result[$fieldID] = $dao->$fieldName;
 482             }
 483           }
 484         }
 485       }
 486     }
 487     return $result;
 488   }
 489
 490   /**
 491    * Take in an array of entityID, custom_XXX => value
 492    * and set the value in the appropriate table. Should also be able
 493    * to set the value to null. Follows api parameter/return conventions
 494    *
 495    * @array $params
 496    *
 497    * @param array $params
 498    *
 499    * @throws Exception
 500    * @return array
 501    * @static
 502    */
 503   public static function setValues(&$params) {
 504
 505     if (!isset($params['entityID']) ||
 506       CRM_Utils_Type::escape($params['entityID'], 'Integer', FALSE) === NULL
 507     ) {
 508       return CRM_Core_Error::createAPIError(ts('entityID needs to be set and of type Integer'));
 509     }
 510
 511     // first collect all the id/value pairs. The format is:
 512     // custom_X => value or custom_X_VALUEID => value (for multiple values), VALUEID == -1, -2 etc for new insertions
 513     $values = array();
 514     $fieldValues = array();
 515     foreach ($params as $n => $v) {
 516       if ($customFieldInfo = CRM_Core_BAO_CustomField::getKeyID($n, TRUE)) {
 517         $fieldID = (int ) $customFieldInfo[0];
 518         if (CRM_Utils_Type::escape($fieldID, 'Integer', FALSE) === NULL) {
 519           return CRM_Core_Error::createAPIError(ts('field ID needs to be of type Integer for index %1',
 520               array(1 => $fieldID)
 521             ));
 522         }
 523         if (!array_key_exists($fieldID, $fieldValues)) {
 524           $fieldValues[$fieldID] = array();
 525         }
 526         $id = -1;
 527         if ($customFieldInfo[1]) {
 528           $id = (int ) $customFieldInfo[1];
 529         }
 530         $fieldValues[$fieldID][] = array(
 531           'value' => $v,
 532           'id' => $id,
 533         );
 534       }
 535     }
 536
 537     $fieldIDList = implode(',', array_keys($fieldValues));
 538
 539     // format it so that we can just use create
 540     $sql = "
 541 SELECT cg.table_name  as table_name ,
 542        cg.id          as cg_id      ,
 543        cg.is_multiple as is_multiple,
 544        cf.column_name as column_name,
 545        cf.id          as cf_id      ,
 546        cf.data_type   as data_type
 547 FROM   civicrm_custom_group cg,
 548        civicrm_custom_field cf
 549 WHERE  cf.custom_group_id = cg.id
 550 AND    cf.id IN ( $fieldIDList )
 551 ";
 552
 553     $dao = CRM_Core_DAO::executeQuery($sql);
 554     $cvParams = array();
 555
 556     while ($dao->fetch()) {
 557       $dataType = $dao->data_type == 'Date' ? 'Timestamp' : $dao->data_type;
 558       foreach ($fieldValues[$dao->cf_id] as $fieldValue) {
 559         // Format null values correctly
 560         if ($fieldValue['value'] === NULL || $fieldValue['value'] === '') {
 561           switch ($dataType) {
 562             case 'String':
 563             case 'Int':
 564             case 'Link':
 565             case 'Boolean':
 566               $fieldValue['value'] = '';
 567               break;
 568
 569             case 'Timestamp':
 570               $fieldValue['value'] = NULL;
 571               break;
 572
 573             case 'StateProvince':
 574             case 'Country':
 575             case 'Money':
 576             case 'Float':
 577               $fieldValue['value'] = (int) 0;
 578               break;
 579           }
 580         }
 581         // Ensure that value is of the right data type
 582         elseif (CRM_Utils_Type::escape($fieldValue['value'], $dataType, FALSE) === NULL) {
 583           return CRM_Core_Error::createAPIError(ts('value: %1 is not of the right field data type: %2',
 584               array(
 585                 1 => $fieldValue['value'],
 586                 2 => $dao->data_type,
 587               )
 588             ));
 589         }
 590
 591         $cvParam = array(
 592           'entity_id' => $params['entityID'],
 593           'value' => $fieldValue['value'],
 594           'type' => $dataType,
 595           'custom_field_id' => $dao->cf_id,
 596           'custom_group_id' => $dao->cg_id,
 597           'table_name' => $dao->table_name,
 598           'column_name' => $dao->column_name,
 599           'is_multiple' => $dao->is_multiple,
 600         );
 601
 602         if ($cvParam['type'] == 'File') {
 603           $cvParam['file_id'] = $fieldValue['value'];
 604         }
 605
 606         if (!array_key_exists($dao->table_name, $cvParams)) {
 607           $cvParams[$dao->table_name] = array();
 608         }
 609
 610         if (!array_key_exists($fieldValue['id'], $cvParams[$dao->table_name])) {
 611           $cvParams[$dao->table_name][$fieldValue['id']] = array();
 612         }
 613
 614         if ($fieldValue['id'] > 0) {
 615           $cvParam['id'] = $fieldValue['id'];
 616         }
 617         $cvParams[$dao->table_name][$fieldValue['id']][] = $cvParam;
 618       }
 619     }
 620
 621     if (!empty($cvParams)) {
 622       self::create($cvParams);
 623       return array('is_error' => 0, 'result' => 1);
 624     }
 625
 626     return CRM_Core_Error::createAPIError(ts('Unknown error'));
 627   }
 628
 629   /**
 630    * Take in an array of entityID, custom_ID
 631    * and gets the value from the appropriate table.
 632    *
 633    * To get the values of custom fields with IDs 13 and 43 for contact ID 1327, use:
 634    * $params = array( 'entityID' => 1327, 'custom_13' => 1, 'custom_43' => 1 );
 635    *
 636    * Entity Type will be infered by the custom fields you request
 637    * Specify $params['entityType'] if you do not supply any custom fields to return
 638    * and entity type is other than Contact
 639    *
 640    * @array $params
 641    *
 642    * @param array $params
 643    *
 644    * @throws Exception
 645    * @return array
 646    * @static
 647    */
 648   public static function &getValues(&$params) {
 649     if (empty($params)) {
 650       return NULL;
 651     }
 652     if (!isset($params['entityID']) ||
 653       CRM_Utils_Type::escape($params['entityID'],
 654         'Integer', FALSE
 655       ) === NULL
 656     ) {
 657       return CRM_Core_Error::createAPIError(ts('entityID needs to be set and of type Integer'));
 658     }
 659
 660     // first collect all the ids. The format is:
 661     // custom_ID
 662     $fieldIDs = array();
 663     foreach ($params as $n => $v) {
 664       $key = $idx = NULL;
 665       if (substr($n, 0, 7) == 'custom_') {
 666         $idx = substr($n, 7);
 667         if (CRM_Utils_Type::escape($idx, 'Integer', FALSE) === NULL) {
 668           return CRM_Core_Error::createAPIError(ts('field ID needs to be of type Integer for index %1',
 669               array(1 => $idx)
 670             ));
 671         }
 672         $fieldIDs[] = (int ) $idx;
 673       }
 674     }
 675
 676     $default = array('Contact', 'Individual', 'Household', 'Organization');
 677     if (!($type = CRM_Utils_Array::value('entityType', $params)) ||
 678       in_array($params['entityType'], $default)
 679     ) {
 680       $type = NULL;
 681     }
 682     else {
 683       $entities = CRM_Core_SelectValues::customGroupExtends();
 684       if (!array_key_exists($type, $entities)) {
 685         if (in_array($type, $entities)) {
 686           $type = $entities[$type];
 687           if (in_array($type, $default)) {
 688             $type = NULL;
 689           }
 690         }
 691         else {
 692           return CRM_Core_Error::createAPIError(ts('Invalid entity type') . ': "' . $type . '"');
 693         }
 694       }
 695     }
 696
 697     $values = self::getEntityValues($params['entityID'],
 698       $type,
 699       $fieldIDs
 700     );
 701     if (empty($values)) {
 702       // note that this behaviour is undesirable from an API point of view - it should return an empty array
 703       // since this is also called by the merger code & not sure the consequences of changing
 704       // are just handling undoing this in the api layer. ie. converting the error back into a success
 705       $result = array(
 706         'is_error' => 1,
 707         'error_message' => 'No values found for the specified entity ID and custom field(s).',
 708       );
 709       return $result;
 710     }
 711     else {
 712       $result = array(
 713         'is_error' => 0,
 714         'entityID' => $params['entityID'],
 715       );
 716       foreach ($values as $id => $value) {
 717         $result["custom_{$id}"] = $value;
 718       }
 719       return $result;
 720     }
 721   }
 722 }