* @package Civi\API\Event
*/
class PrepareEvent extends Event {
+
/**
* @param array $apiRequest
* The full description of the API request.
* @package Civi\API\Event
*/
class ResolveEvent extends Event {
+
/**
* @param array $apiRequest
* The full description of the API request.
* @package Civi\API\Exception
*/
class NotImplementedException extends \API_Exception {
+
/**
* @param string $message
* The human friendly error message.
* @package Civi\API\Exception
*/
class UnauthorizedException extends \API_Exception {
+
/**
* @param string $message
* The human friendly error message.
while (!empty($this->processes)) {
usleep(self::POLL_INTERVAL);
foreach (array_keys($this->processes) as $idx) {
- /** @var Process $process */
+ /** @var \Symfony\Component\Process\Process $process */
$process = $this->processes[$idx];
if (!$process->isRunning()) {
$parsed = json_decode($process->getOutput(), TRUE);
/**
* @param array $apiCall
* Array with keys: entity, action, params.
- * @return Process
+ * @return \Symfony\Component\Process\Process
* @throws \CRM_Core_Exception
*/
public function createProcess($apiCall) {
use Civi\API\Event\ExceptionEvent;
use Civi\API\Event\ResolveEvent;
use Civi\API\Event\RespondEvent;
-use Civi\API\Provider\ProviderInterface;
/**
* @package Civi
* Array(0 => ProviderInterface, 1 => array $apiRequest).
*/
public function resolve($apiRequest) {
- /** @var ResolveEvent $resolveEvent */
+ /** @var \Civi\API\Event\ResolveEvent $resolveEvent */
$resolveEvent = $this->dispatcher->dispatch(Events::RESOLVE, new ResolveEvent($apiRequest, $this));
$apiRequest = $resolveEvent->getApiRequest();
if (!$resolveEvent->getApiProvider()) {
/**
* Determine if the API request is allowed (under current policy)
*
- * @param ProviderInterface $apiProvider
+ * @param \Civi\API\Provider\ProviderInterface $apiProvider
* The API provider responsible for executing the request.
* @param array $apiRequest
* The full description of the API request.
* @throws Exception\UnauthorizedException
*/
public function authorize($apiProvider, $apiRequest) {
- /** @var AuthorizeEvent $event */
+ /** @var \Civi\API\Event\AuthorizeEvent $event */
$event = $this->dispatcher->dispatch(Events::AUTHORIZE, new AuthorizeEvent($apiProvider, $apiRequest, $this));
if (!$event->isAuthorized()) {
throw new \Civi\API\Exception\UnauthorizedException("Authorization failed");
/**
* Allow third-party code to manipulate the API request before execution.
*
- * @param ProviderInterface $apiProvider
+ * @param \Civi\API\Provider\ProviderInterface $apiProvider
* The API provider responsible for executing the request.
* @param array $apiRequest
* The full description of the API request.
* The revised API request.
*/
public function prepare($apiProvider, $apiRequest) {
- /** @var PrepareEvent $event */
+ /** @var \Civi\API\Event\PrepareEvent $event */
$event = $this->dispatcher->dispatch(Events::PREPARE, new PrepareEvent($apiProvider, $apiRequest, $this));
return $event->getApiRequest();
}
/**
* Allow third-party code to manipulate the API response after execution.
*
- * @param ProviderInterface $apiProvider
+ * @param \Civi\API\Provider\ProviderInterface $apiProvider
* The API provider responsible for executing the request.
* @param array $apiRequest
* The full description of the API request.
* The revised $result.
*/
public function respond($apiProvider, $apiRequest, $result) {
- /** @var RespondEvent $event */
+ /** @var \Civi\API\Event\RespondEvent $event */
$event = $this->dispatcher->dispatch(Events::RESPOND, new RespondEvent($apiProvider, $apiRequest, $result, $this));
return $event->getResponse();
}
// Question: Would it better to eliminate $this->apiProviders and just use $this->dispatcher?
$entityNames = [];
foreach ($this->getApiProviders() as $provider) {
- /** @var ProviderInterface $provider */
+ /** @var \Civi\API\Provider\ProviderInterface $provider */
$entityNames = array_merge($entityNames, $provider->getEntityNames($version));
}
$entityNames = array_unique($entityNames);
// Question: Would it better to eliminate $this->apiProviders and just use $this->dispatcher?
$actionNames = [];
foreach ($this->getApiProviders() as $provider) {
- /** @var ProviderInterface $provider */
+ /** @var \Civi\API\Provider\ProviderInterface $provider */
$actionNames = array_merge($actionNames, $provider->getActionNames($version, $entity));
}
$actionNames = array_unique($actionNames);
$data['action'] = \CRM_Utils_Array::value('action', $apiRequest);
if (\CRM_Utils_Array::value('debug', \CRM_Utils_Array::value('params', $apiRequest))
- && empty($data['trace']) // prevent recursion
+ // prevent recursion
+ && empty($data['trace'])
) {
$data['trace'] = $e->getTraceAsString();
}
}
/**
- * @param ProviderInterface $apiProvider
+ * @param \Civi\API\Provider\ProviderInterface $apiProvider
* The API provider responsible for executing the request.
* @return Kernel
*/
* conventions.
*/
class MagicFunctionProvider implements EventSubscriberInterface, ProviderInterface {
+
/**
* @return array
*/
}
// Check for standalone action files; to match _civicrm_api_resolve(), only load the first one
- $loaded_files = []; // array($relativeFilePath => TRUE)
+ // array($relativeFilePath => TRUE)
+ $loaded_files = [];
$include_dirs = array_unique(explode(PATH_SEPARATOR, get_include_path()));
foreach ($include_dirs as $include_dir) {
foreach ([$camelName, 'Generic'] as $name) {
foreach ($iterator as $fileinfo) {
$file = $fileinfo->getFilename();
if (array_key_exists($file, $loaded_files)) {
- continue; // action provided by an earlier item on include_path
+ // action provided by an earlier item on include_path
+ continue;
}
$parts = explode(".", $file);
namespace Civi\API\Provider;
-use Civi\API\Events;
-use Symfony\Component\EventDispatcher\EventSubscriberInterface;
-
/**
* An API "provider" provides a means to execute API requests.
*/
interface ProviderInterface {
+
/**
* @param array $apiRequest
* The full description of the API request.
* This class defines operations for inspecting the API's metadata.
*/
class ReflectionProvider implements EventSubscriberInterface, ProviderInterface {
+
/**
* @return array
*/
$this->apiKernel = $apiKernel;
$this->actions = [
'Entity' => ['get', 'getactions'],
- '*' => ['getactions'], // 'getfields'
+ // 'getfields'
+ '*' => ['getactions'],
];
}
* @param array $apiRequest
* The full description of the API request.
* @return array
- * Formatted API result
+ * Formatted API result
* @throws \API_Exception
*/
public function doCreate($apiRequest) {
* @param array $apiRequest
* The full description of the API request.
* @return array
- * Formatted API result
+ * Formatted API result
* @throws \API_Exception
*/
public function doGet($apiRequest) {
* @param array $apiRequest
* The full description of the API request.
* @return array
- * Formatted API result
+ * Formatted API result
* @throws \API_Exception
*/
public function doDelete($apiRequest) {
+--------------------------------------------------------------------+
*/
namespace Civi\API;
+
use Civi\API\Exception\UnauthorizedException;
/**
* and validates that the fields are provided correctly.
*/
class APIv3SchemaAdapter implements EventSubscriberInterface {
+
/**
* @return array
*/
* eg Amy's contact_id).
*/
class ChainSubscriber implements EventSubscriberInterface {
+
/**
* @return array
*/
$exception = NULL;
$self = $this;
\CRM_Core_Transaction::create(TRUE)->run(function($tx) use ($entity, $action, $entityId, &$exception, $self) {
- $tx->rollback(); // Just to be safe.
+ // Just to be safe.
+ $tx->rollback();
$params = [
'version' => 3,
* @package Civi\API\Subscriber
*/
class I18nSubscriber implements EventSubscriberInterface {
+
/**
* @return array
*/
* Civi\API\Annotation\Permission.
*/
class PermissionCheck implements EventSubscriberInterface {
+
/**
* @return array
*/
* @package Civi\API\Subscriber
*/
class TransactionSubscriber implements EventSubscriberInterface {
+
/**
* @return array
*/
use Civi\API\Events;
use Civi\API\Event\AuthorizeEvent;
use Civi\API\Event\RespondEvent;
-use Civi\API\WhitelistRule;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
/**
public function __construct($rules) {
$this->rules = [];
foreach ($rules as $rule) {
- /** @var WhitelistRule $rule */
+ /** @var \Civi\API\WhitelistRule $rule */
if ($rule->isValid()) {
$this->rules[] = $rule;
}
* Determine which, if any, whitelist rules apply this request.
* Reject unauthorized requests.
*
- * @param AuthorizeEvent $event
+ * @param \Civi\API\Event\AuthorizeEvent $event
* @throws \CRM_Core_Exception
*/
public function onApiAuthorize(AuthorizeEvent $event) {
/**
* Apply any filtering rules based on the chosen whitelist rule.
- * @param RespondEvent $event
+ * @param \Civi\API\Event\RespondEvent $event
*/
public function onApiRespond(RespondEvent $event) {
$apiRequest = $event->getApiRequest();
* @package Civi\API\Subscriber
*/
class XDebugSubscriber implements EventSubscriberInterface {
+
/**
* @return array
*/
*/
class WhitelistRule {
- static $IGNORE_FIELDS = [
+ public static $IGNORE_FIELDS = [
'check_permissions',
'debug',
'offset',
<?php
namespace Civi\ActionSchedule\Event;
-use Civi\ActionSchedule\MappingInterface;
use Symfony\Component\EventDispatcher\Event;
/**
/**
* The mapping record which produced this mailing.
*
- * @var MappingInterface
+ * @var \Civi\ActionSchedule\MappingInterface
*/
public $mapping;
/**
* @param \CRM_Core_DAO_ActionSchedule $actionSchedule
- * @param MappingInterface $mapping
+ * @param \Civi\ActionSchedule\MappingInterface $mapping
* @param \CRM_Utils_SQL_Select $query
*/
public function __construct($actionSchedule, $mapping, $query) {
/**
* Register a new mapping.
*
- * @param MappingInterface $mapping
+ * @param \Civi\ActionSchedule\MappingInterface $mapping
* The new mapping.
* @return MappingRegisterEvent
*/
/**
* The basic entity to query (label).
*
- * @var
+ * @var string
* Ex: 'Activity', 'Event'
*/
private $entity_label;
* @param array $defaultParams
* @return \CRM_Utils_SQL_Select
*/
- public abstract function createQuery($schedule, $phase, $defaultParams);
+ abstract public function createQuery($schedule, $phase, $defaultParams);
}
/**
* @param \CRM_Core_Resources $res
* The resource manager.
+ * @param $cache
*/
public function __construct($res, \CRM_Utils_Cache_Interface $cache = NULL) {
$this->res = $res;
* @package Civi\CCase
*/
interface CaseChangeListener {
+
/**
* @param \Civi\CCase\Event\CaseChangeEvent $event
*
*/
namespace Civi\CCase\Event;
+
use Civi\Core\Event\GenericHookEvent;
/**
*
* We do not want to fire case-change events recursively.
*/
- static $isActive = [];
+ public static $isActive = [];
/**
* Following a change to an activity or case, fire the case-change event.
* @package Civi\CiUtil
*/
class Arrays {
+
/**
* @param $arr
* @param $col
* @package Civi\CiUtil\Command
*/
class AntagonistCommand {
+
/**
* @param $argv
*/
* @package Civi\CiUtil\Command
*/
class CompareCommand {
+
/**
* @param $argv
*/
$parser = ['\Civi\CiUtil\PHPUnitParser', 'parseJsonResults'];
$printerType = 'txt';
- $suites = []; // array('file' => string, 'results' => array)
+ // array('file' => string, 'results' => array)
+ $suites = [];
for ($i = 1; $i < count($argv); $i++) {
switch ($argv[$i]) {
case '--phpunit-json':
}
}
- $tests = []; // array(string $name)
+ // array(string $name)
+ $tests = [];
foreach ($suites as $suite) {
$tests = array_unique(array_merge(
$tests,
* @package Civi\CiUtil\Command
*/
class LsCommand {
+
/**
* @param $argv
*/
* @package Civi\CiUtil
*/
class ComparisonPrinter {
- var $headers;
- var $hasHeader = FALSE;
+ public $headers;
+ public $hasHeader = FALSE;
/**
* @param $headers
* @package Civi\CiUtil
*/
class CsvPrinter {
- var $file;
- var $headers;
- var $hasHeader = FALSE;
+ public $file;
+ public $headers;
+ public $hasHeader = FALSE;
/**
* @param $file
* Parse Jenkins result files
*/
class JenkinsParser {
+
/**
* @param string $content
* Xml data.
* Parse phpunit result files
*/
class PHPUnitParser {
+
/**
* @param string $content
* Phpunit streaming JSON.
* Search for PHPUnit test cases
*/
class PHPUnitScanner {
+
/**
* @param $path
* @return array <string> class names
];
}
+ /**
+ * @var mixed
+ */
protected $cacheEnabled;
/**
protected function getCachePath($fileName = NULL) {
// imageUploadDir has the correct functional properties but a wonky name.
$suffix = ($fileName === NULL) ? '' : (DIRECTORY_SEPARATOR . $fileName);
- return
- \CRM_Utils_File::addTrailingSlash(\CRM_Core_Config::singleton()->imageUploadDir)
+ return \CRM_Utils_File::addTrailingSlash(\CRM_Core_Config::singleton()->imageUploadDir)
. 'dyn' . $suffix;
}
protected function getCacheUrl($fileName = NULL) {
// imageUploadURL has the correct functional properties but a wonky name.
$suffix = ($fileName === NULL) ? '' : ('/' . $fileName);
- return
- \CRM_Utils_File::addTrailingSlash(\CRM_Core_Config::singleton()->imageUploadURL, '/')
+ return \CRM_Utils_File::addTrailingSlash(\CRM_Core_Config::singleton()->imageUploadURL, '/')
. 'dyn' . $suffix;
}
<?php
namespace Civi\Core;
-use Civi\API\Provider\ActionObjectProvider;
use Civi\Core\Event\SystemInstallEvent;
use Civi\Core\Lock\LockManager;
-use Doctrine\Common\Annotations\AnnotationReader;
-use Doctrine\Common\Annotations\AnnotationRegistry;
-use Doctrine\Common\Annotations\FileCacheReader;
-use Doctrine\Common\Cache\FilesystemCache;
-use Doctrine\ORM\EntityManager;
-use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
-use Doctrine\ORM\Tools\Setup;
use Symfony\Component\Config\ConfigCache;
use Symfony\Component\DependencyInjection\ContainerBuilder;
-use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
use Symfony\Component\DependencyInjection\Reference;
-use Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher;
use Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass;
// TODO use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
* - CIVICRM_DOMAIN_ID
* - CIVICRM_TEMPLATE_COMPILEDIR
*
- * @return ContainerInterface
+ * @return \Symfony\Component\DependencyInjection\ContainerInterface
*/
public function loadContainer() {
// Note: The container's raison d'etre is to manage construction of other
/**
* Construct a new container.
*
- * @var ContainerBuilder
+ * @var \Symfony\Component\DependencyInjection\ContainerBuilder
* @return \Symfony\Component\DependencyInjection\ContainerBuilder
*/
public function createContainer() {
}
/**
- * @param ContainerInterface $container
+ * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
* @return \Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher
*/
public function createEventDispatcher($container) {
}
/**
- * @return LockManager
+ * @return \Civi\Core\Lock\LockManager
*/
public static function createLockManager() {
// Ideally, downstream implementers could override any definitions in
}
/**
- * @param ContainerInterface $container
+ * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
* @return \CRM_Core_Resources
*/
public static function createResources($container) {
}
/**
- * @param ContainerInterface $container
+ * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
* @return \CRM_Core_PrevNextCache_Interface
*/
public static function createPrevNextCache($container) {
namespace Civi\Core;
-use Civi;
use Civi\Core\Event\SystemInstallEvent;
/**
}
class ResolverGlobalCallback {
- private $mode, $path;
+ private $mode;
+ private $path;
/**
* Class constructor.
protected $cache;
/**
- * @var
+ * @var array
* Array (int $id => SettingsBag $bag).
*/
- protected $bagsByDomain = [], $bagsByContact = [];
+ protected $bagsByDomain = [];
+
+
+ /**
+ * @var array
+ * Array (int $id => SettingsBag $bag).
+ */
+ protected $bagsByContact = [];
/**
* @var array|NULL
$this->mandatory = NULL;
$this->cache->flush();
- \Civi::cache('settings')->flush(); // SettingsMetadata; not guaranteed to use same cache.
+ // SettingsMetadata; not guaranteed to use same cache.
+ \Civi::cache('settings')->flush();
foreach ($this->bagsByDomain as $bag) {
/** @var SettingsBag $bag */
$this->triggers = $triggers;
}
-
/**
* Add our list of triggers to the global list.
*
namespace Civi\Core\SqlTrigger;
-use Civi\Core\Event\GenericHookEvent;
-
/**
* Build a set of SQL triggers for tracking timestamps on an entity.
*
if (!file_exists($this->getFile())) {
// Ugh. Need to let user know somehow. This is the first change.
\CRM_Core_Session::setStatus(ts('The mysql commands you need to run are stored in %1', [
- 1 => $this->getFile(),
- ]),
+ 1 => $this->getFile(),
+ ]),
'',
'alert',
['expires' => 0]
*/
const REQUIREMENT_ERROR = 2;
+ /**
+ * @var array
+ */
protected $system_checks = [
'checkMemory',
'checkServerVariables',
/**
* Generates a mysql connection
*
- * @param $db_confic array
+ * @param $db_config array
* @return object mysqli connection
*/
protected function connect($db_config) {
return $results;
}
- $r = mysqli_query($conn, "SHOW VARIABLES LIKE 'thread_stack'"); // bytes => kb
+ // bytes => kb
+ $r = mysqli_query($conn, "SHOW VARIABLES LIKE 'thread_stack'");
if (!$r) {
$results['severity'] = $this::REQUIREMENT_ERROR;
$results['details'] = 'Could not query thread_stack value';
/**
* Get a connection to the test database.
*
- * @return PDO
+ * @return \PDO
*/
public static function pdo() {
if (!isset(self::$singletons['pdo'])) {
return self::$singletons['schema'];
}
-
/**
* @return \Civi\Test\Data
*/
/**
* Api version - easier to override than just a define
+ * @var int
*/
protected $_apiversion = 3;
throw new \Exception(
'Invalid getsingle result' . print_r($result, TRUE)
. "\n entity: $entity . \n params \n " . print_r($params, TRUE)
- . "\n entities retrieved with blank params \n" . print_r($unfilteredResult, TRUE)
+ . "\n entities retrieved with blank params \n" . print_r($unfilteredResult, TRUE)
);
}
if ($checkAgainst) {
<?php
namespace Civi\Test\CiviEnvBuilder;
+
class CallbackStep implements StepInterface {
private $callback;
private $sig;
<?php
namespace Civi\Test\CiviEnvBuilder;
+
class ExtensionsStep implements StepInterface {
private $action;
private $names;
$this->file = $file;
}
-
public function getSig() {
return implode(' ', [
$this->file,
<?php
namespace Civi\Test\CiviEnvBuilder;
+
class SqlStep implements StepInterface {
private $sql;
$this->sql = $sql;
}
-
public function getSig() {
return md5($this->sql);
}
namespace Civi\Test\CiviEnvBuilder;
interface StepInterface {
+
public function getSig();
public function isValid();
\CRM_Utils_System::flushCache();
\Civi::reset();
\CRM_Core_Session::singleton()->set('userID', NULL);
- $config = \CRM_Core_Config::singleton(TRUE, TRUE); // ugh, performance
+ // ugh, performance
+ $config = \CRM_Core_Config::singleton(TRUE, TRUE);
if (property_exists($config->userPermissionClass, 'permissions')) {
$config->userPermissionClass->permissions = NULL;
/**
* Register the declared tokens.
*
- * @param TokenRegisterEvent $e
+ * @param \Civi\Token\Event\TokenRegisterEvent $e
* The registration event. Add new tokens using register().
*/
public function registerTokens(TokenRegisterEvent $e) {
* This is method is not always appropriate, but if you're specifically
* focused on scheduled reminders, it can be convenient.
*
- * @param MailingQueryEvent $e
+ * @param \Civi\ActionSchedule\Event\MailingQueryEvent $e
* The pending query which may be modified. See discussion on
* MailingQueryEvent::$query.
*/
/**
* Populate the token data.
*
- * @param TokenValueEvent $e
+ * @param \Civi\Token\Event\TokenValueEvent $e
* The event, which includes a list of rows and tokens.
*/
public function evaluateTokens(TokenValueEvent $e) {
* Any data that was returned by the prefetch().
* @return mixed
*/
- public abstract function evaluateToken(TokenRow $row, $entity, $field, $prefetch = NULL);
+ abstract public function evaluateToken(TokenRow $row, $entity, $field, $prefetch = NULL);
}
/**
* Load token data.
*
- * @param TokenValueEvent $e
+ * @param \Civi\Token\Event\TokenValueEvent $e
* @throws TokenException
*/
public function onEvaluate(TokenValueEvent $e) {
['contact_id', '=', $contactId, 0, 0],
];
list($contact, $_) = \CRM_Contact_BAO_Query::apiQuery($params);
- $contact = reset($contact); //CRM-4524
+ //CRM-4524
+ $contact = reset($contact);
if (!$contact || is_a($contact, 'CRM_Core_Error')) {
// FIXME: Need to differentiate errors which kill the batch vs the individual row.
throw new TokenException("Failed to generate token data. Invalid contact ID: " . $row->context['contactId']);
/**
* Apply the various CRM_Utils_Token helpers.
*
- * @param TokenRenderEvent $e
+ * @param \Civi\Token\Event\TokenRenderEvent $e
*/
public function onRender(TokenRenderEvent $e) {
$isHtml = ($e->message['format'] == 'text/html');
use Civi\Token\Event\TokenRegisterEvent;
use Civi\Token\Event\TokenRenderEvent;
use Civi\Token\Event\TokenValueEvent;
-use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Traversable;
class TokenProcessor {
public $context;
/**
- * @var EventDispatcherInterface
+ * @var \Symfony\Component\EventDispatcher\EventDispatcherInterface
*/
protected $dispatcher;
protected $next = 0;
/**
- * @param EventDispatcherInterface $dispatcher
+ * @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher
* @param array $context
*/
public function __construct($dispatcher, $context) {
*
* @param string $field
* Ex: 'contactId'.
+ * @param $subfield
* @return array
* Ex: [12, 34, 56].
*/
$row->fill($message['format']);
$useSmarty = !empty($row->context['smarty']);
- // FIXME preg_callback.
+ /**
+ *@FIXME preg_callback.
+ */
$tokens = $this->rowValues[$row->tokenRow][$message['format']];
$flatTokens = [];
\CRM_Utils_Array::flatten($tokens, $flatTokens, '', '.');
/**
* @param TokenProcessor $tokenProcessor
- * @param Traversable $iterator
+ * @param \Traversable $iterator
*/
public function __construct(TokenProcessor $tokenProcessor, Traversable $iterator) {
- parent::__construct($iterator); // TODO: Change the autogenerated stub
+ // TODO: Change the autogenerated stub
+ parent::__construct($iterator);
$this->tokenProcessor = $tokenProcessor;
}
public function __construct(TokenProcessor $tokenProcessor, $key) {
$this->tokenProcessor = $tokenProcessor;
$this->tokenRow = $key;
- $this->format('text/plain'); // Set a default.
+ // Set a default.
+ $this->format('text/plain');
$this->context = new TokenRowContext($tokenProcessor, $key);
}
$customFieldName = "custom_" . $customFieldID;
$record = civicrm_api3($entity, "getSingle", [
'return' => $customFieldName,
- 'id' => $entityID,
+ 'id' => $entityID,
]);
$fieldValue = \CRM_Utils_Array::value($customFieldName, $record, '');
* @return bool
*/
public function offsetExists($offset) {
- return
- isset($this->tokenProcessor->rowContexts[$this->tokenRow][$offset])
+ return isset($this->tokenProcessor->rowContexts[$this->tokenRow][$offset])
|| isset($this->tokenProcessor->context[$offset]);
}
projects / civicrm-core.git / commitdiff