CRM/Core/ManagedEntities.php

   1 <?php
   2
   3 /**
   4  * The ManagedEntities system allows modules to add records to the database
   5  * declaratively.  Those records will be automatically inserted, updated,
   6  * deactivated, and deleted in tandem with their modules.
   7  */
   8 class CRM_Core_ManagedEntities {
   9
  10   /**
  11    * Get clean up options.
  12    *
  13    * @return array
  14    */
  15   public static function getCleanupOptions() {
  16     return [
  17       'always' => ts('Always'),
  18       'never' => ts('Never'),
  19       'unused' => ts('If Unused'),
  20     ];
  21   }
  22
  23   /**
  24    * @var array
  25    *   Array($status => array($name => CRM_Core_Module)).
  26    */
  27   protected $moduleIndex;
  28
  29   /**
  30    * @var array
  31    *   List of all entity declarations.
  32    * @see CRM_Utils_Hook::managed()
  33    */
  34   protected $declarations;
  35
  36   /**
  37    * Get an instance.
  38    * @param bool $fresh
  39    * @return \CRM_Core_ManagedEntities
  40    */
  41   public static function singleton($fresh = FALSE) {
  42     static $singleton;
  43     if ($fresh || !$singleton) {
  44       $singleton = new CRM_Core_ManagedEntities(CRM_Core_Module::getAll(), NULL);
  45     }
  46     return $singleton;
  47   }
  48
  49   /**
  50    * Perform an asynchronous reconciliation when the transaction ends.
  51    */
  52   public static function scheduleReconciliation() {
  53     CRM_Core_Transaction::addCallback(
  54       CRM_Core_Transaction::PHASE_POST_COMMIT,
  55       function () {
  56         CRM_Core_ManagedEntities::singleton(TRUE)->reconcile();
  57       },
  58       [],
  59       'ManagedEntities::reconcile'
  60     );
  61   }
  62
  63   /**
  64    * @param array $modules
  65    *   CRM_Core_Module.
  66    * @param array $declarations
  67    *   Per hook_civicrm_managed.
  68    */
  69   public function __construct($modules, $declarations) {
  70     $this->moduleIndex = self::createModuleIndex($modules);
  71
  72     if ($declarations !== NULL) {
  73       $this->declarations = self::cleanDeclarations($declarations);
  74     }
  75     else {
  76       $this->declarations = NULL;
  77     }
  78   }
  79
  80   /**
  81    * Read a managed entity using APIv3.
  82    *
  83    * @param string $moduleName
  84    *   The name of the module which declared entity.
  85    * @param string $name
  86    *   The symbolic name of the entity.
  87    * @return array|NULL
  88    *   API representation, or NULL if the entity does not exist
  89    */
  90   public function get($moduleName, $name) {
  91     $dao = new CRM_Core_DAO_Managed();
  92     $dao->module = $moduleName;
  93     $dao->name = $name;
  94     if ($dao->find(TRUE)) {
  95       $params = [
  96         'id' => $dao->entity_id,
  97       ];
  98       $result = NULL;
  99       try {
 100         $result = civicrm_api3($dao->entity_type, 'getsingle', $params);
 101       }
 102       catch (Exception $e) {
 103         $this->onApiError($dao->entity_type, 'getsingle', $params, $result);
 104       }
 105       return $result;
 106     }
 107     else {
 108       return NULL;
 109     }
 110   }
 111
 112   /**
 113    * Identify any enabled/disabled modules. Add new entities, update
 114    * existing entities, and remove orphaned (stale) entities.
 115    * @param bool $ignoreUpgradeMode
 116    *
 117    * @throws Exception
 118    */
 119   public function reconcile($ignoreUpgradeMode = FALSE) {
 120     // Do not reconcile whilst we are in upgrade mode
 121     if (CRM_Core_Config::singleton()->isUpgradeMode() && !$ignoreUpgradeMode) {
 122       return;
 123     }
 124     if ($error = $this->validate($this->getDeclarations())) {
 125       throw new Exception($error);
 126     }
 127     $this->reconcileEnabledModules();
 128     $this->reconcileDisabledModules();
 129     $this->reconcileUnknownModules();
 130   }
 131
 132   /**
 133    * For all enabled modules, add new entities, update
 134    * existing entities, and remove orphaned (stale) entities.
 135    *
 136    * @throws Exception
 137    */
 138   public function reconcileEnabledModules() {
 139     // Note: any thing currently declared is necessarily from
 140     // an active module -- because we got it from a hook!
 141
 142     // index by moduleName,name
 143     $decls = self::createDeclarationIndex($this->moduleIndex, $this->getDeclarations());
 144     foreach ($decls as $moduleName => $todos) {
 145       if (isset($this->moduleIndex[TRUE][$moduleName])) {
 146         $this->reconcileEnabledModule($this->moduleIndex[TRUE][$moduleName], $todos);
 147       }
 148       elseif (isset($this->moduleIndex[FALSE][$moduleName])) {
 149         // do nothing -- module should get swept up later
 150       }
 151       else {
 152         throw new Exception("Entity declaration references invalid or inactive module name [$moduleName]");
 153       }
 154     }
 155   }
 156
 157   /**
 158    * For one enabled module, add new entities, update existing entities,
 159    * and remove orphaned (stale) entities.
 160    *
 161    * @param \CRM_Core_Module $module
 162    * @param array $todos
 163    *   List of entities currently declared by this module.
 164    *   array(string $name => array $entityDef).
 165    */
 166   public function reconcileEnabledModule(CRM_Core_Module $module, $todos) {
 167     $dao = new CRM_Core_DAO_Managed();
 168     $dao->module = $module->name;
 169     $dao->find();
 170     while ($dao->fetch()) {
 171       if (isset($todos[$dao->name]) && $todos[$dao->name]) {
 172         // update existing entity; remove from $todos
 173         $this->updateExistingEntity($dao, $todos[$dao->name]);
 174         unset($todos[$dao->name]);
 175       }
 176       else {
 177         // remove stale entity; not in $todos
 178         $this->removeStaleEntity($dao);
 179       }
 180     }
 181
 182     // create new entities from leftover $todos
 183     foreach ($todos as $name => $todo) {
 184       $this->insertNewEntity($todo);
 185     }
 186   }
 187
 188   /**
 189    * For all disabled modules, disable any managed entities.
 190    */
 191   public function reconcileDisabledModules() {
 192     if (empty($this->moduleIndex[FALSE])) {
 193       return;
 194     }
 195
 196     $in = CRM_Core_DAO::escapeStrings(array_keys($this->moduleIndex[FALSE]));
 197     $dao = new CRM_Core_DAO_Managed();
 198     $dao->whereAdd("module in ($in)");
 199     $dao->orderBy('id DESC');
 200     $dao->find();
 201     while ($dao->fetch()) {
 202       $this->disableEntity($dao);
 203
 204     }
 205   }
 206
 207   /**
 208    * Remove any orphaned (stale) entities that are linked to
 209    * unknown modules.
 210    */
 211   public function reconcileUnknownModules() {
 212     $knownModules = [];
 213     if (array_key_exists(0, $this->moduleIndex) && is_array($this->moduleIndex[0])) {
 214       $knownModules = array_merge($knownModules, array_keys($this->moduleIndex[0]));
 215     }
 216     if (array_key_exists(1, $this->moduleIndex) && is_array($this->moduleIndex[1])) {
 217       $knownModules = array_merge($knownModules, array_keys($this->moduleIndex[1]));
 218     }
 219
 220     $dao = new CRM_Core_DAO_Managed();
 221     if (!empty($knownModules)) {
 222       $in = CRM_Core_DAO::escapeStrings($knownModules);
 223       $dao->whereAdd("module NOT IN ($in)");
 224       $dao->orderBy('id DESC');
 225     }
 226     $dao->find();
 227     while ($dao->fetch()) {
 228       $this->removeStaleEntity($dao);
 229     }
 230   }
 231
 232   /**
 233    * Create a new entity.
 234    *
 235    * @param array $todo
 236    *   Entity specification (per hook_civicrm_managedEntities).
 237    */
 238   public function insertNewEntity($todo) {
 239     $result = civicrm_api($todo['entity'], 'create', $todo['params']);
 240     if ($result['is_error']) {
 241       $this->onApiError($todo['entity'], 'create', $todo['params'], $result);
 242     }
 243
 244     $dao = new CRM_Core_DAO_Managed();
 245     $dao->module = $todo['module'];
 246     $dao->name = $todo['name'];
 247     $dao->entity_type = $todo['entity'];
 248     $dao->entity_id = $result['id'];
 249     $dao->cleanup = $todo['cleanup'] ?? NULL;
 250     $dao->save();
 251   }
 252
 253   /**
 254    * Update an entity which is believed to exist.
 255    *
 256    * @param CRM_Core_DAO_Managed $dao
 257    * @param array $todo
 258    *   Entity specification (per hook_civicrm_managedEntities).
 259    */
 260   public function updateExistingEntity($dao, $todo) {
 261     $policy = CRM_Utils_Array::value('update', $todo, 'always');
 262     $doUpdate = ($policy == 'always');
 263
 264     if ($doUpdate) {
 265       $defaults = ['id' => $dao->entity_id, 'is_active' => 1];
 266       $params = array_merge($defaults, $todo['params']);
 267
 268       $manager = CRM_Extension_System::singleton()->getManager();
 269       if ($dao->entity_type === 'Job' && !$manager->extensionIsBeingInstalledOrEnabled($dao->module)) {
 270         // Special treatment for scheduled jobs:
 271         //
 272         // If we're being called as part of enabling/installing a module then
 273         // we want the default behaviour of setting is_active = 1.
 274         //
 275         // However, if we're just being called by a normal cache flush then we
 276         // should not re-enable a job that an administrator has decided to disable.
 277         //
 278         // Without this logic there was a problem: site admin might disable
 279         // a job, but then when there was a flush op, the job was re-enabled
 280         // which can cause significant embarrassment, depending on the job
 281         // ("Don't worry, sending mailings is disabled right now...").
 282         unset($params['is_active']);
 283       }
 284
 285       $result = civicrm_api($dao->entity_type, 'create', $params);
 286       if ($result['is_error']) {
 287         $this->onApiError($dao->entity_type, 'create', $params, $result);
 288       }
 289     }
 290
 291     if (isset($todo['cleanup'])) {
 292       $dao->cleanup = $todo['cleanup'];
 293       $dao->update();
 294     }
 295   }
 296
 297   /**
 298    * Update an entity which (a) is believed to exist and which (b) ought to be
 299    * inactive.
 300    *
 301    * @param CRM_Core_DAO_Managed $dao
 302    */
 303   public function disableEntity($dao) {
 304     // FIXME: if ($dao->entity_type supports is_active) {
 305     if (TRUE) {
 306       // FIXME cascading for payproc types?
 307       $params = [
 308         'version' => 3,
 309         'id' => $dao->entity_id,
 310         'is_active' => 0,
 311       ];
 312       $result = civicrm_api($dao->entity_type, 'create', $params);
 313       if ($result['is_error']) {
 314         $this->onApiError($dao->entity_type, 'create', $params, $result);
 315       }
 316     }
 317   }
 318
 319   /**
 320    * Remove a stale entity (if policy allows).
 321    *
 322    * @param CRM_Core_DAO_Managed $dao
 323    * @throws Exception
 324    */
 325   public function removeStaleEntity($dao) {
 326     $policy = empty($dao->cleanup) ? 'always' : $dao->cleanup;
 327     switch ($policy) {
 328       case 'always':
 329         $doDelete = TRUE;
 330         break;
 331
 332       case 'never':
 333         $doDelete = FALSE;
 334         break;
 335
 336       case 'unused':
 337         $getRefCount = civicrm_api3($dao->entity_type, 'getrefcount', [
 338           'debug' => 1,
 339           'id' => $dao->entity_id,
 340         ]);
 341
 342         $total = 0;
 343         foreach ($getRefCount['values'] as $refCount) {
 344           $total += $refCount['count'];
 345         }
 346
 347         $doDelete = ($total == 0);
 348         break;
 349
 350       default:
 351         throw new \Exception('Unrecognized cleanup policy: ' . $policy);
 352     }
 353
 354     if ($doDelete) {
 355       $params = [
 356         'version' => 3,
 357         'id' => $dao->entity_id,
 358       ];
 359       $check = civicrm_api3($dao->entity_type, 'get', $params);
 360       if ((bool) $check['count']) {
 361         $result = civicrm_api($dao->entity_type, 'delete', $params);
 362         if ($result['is_error']) {
 363           $this->onApiError($dao->entity_type, 'delete', $params, $result);
 364         }
 365       }
 366       CRM_Core_DAO::executeQuery('DELETE FROM civicrm_managed WHERE id = %1', [
 367         1 => [$dao->id, 'Integer'],
 368       ]);
 369     }
 370   }
 371
 372   /**
 373    * Get declarations.
 374    *
 375    * @return array|null
 376    */
 377   public function getDeclarations() {
 378     if ($this->declarations === NULL) {
 379       $this->declarations = [];
 380       foreach (CRM_Core_Component::getEnabledComponents() as $component) {
 381         /** @var CRM_Core_Component_Info $component */
 382         $this->declarations = array_merge($this->declarations, $component->getManagedEntities());
 383       }
 384       CRM_Utils_Hook::managed($this->declarations);
 385       $this->declarations = self::cleanDeclarations($this->declarations);
 386     }
 387     return $this->declarations;
 388   }
 389
 390   /**
 391    * @param array $modules
 392    *   Array<CRM_Core_Module>.
 393    *
 394    * @return array
 395    *   indexed by is_active,name
 396    */
 397   protected static function createModuleIndex($modules) {
 398     $result = [];
 399     foreach ($modules as $module) {
 400       $result[$module->is_active][$module->name] = $module;
 401     }
 402     return $result;
 403   }
 404
 405   /**
 406    * @param array $moduleIndex
 407    * @param array $declarations
 408    *
 409    * @return array
 410    *   indexed by module,name
 411    */
 412   protected static function createDeclarationIndex($moduleIndex, $declarations) {
 413     $result = [];
 414     if (!isset($moduleIndex[TRUE])) {
 415       return $result;
 416     }
 417     foreach ($moduleIndex[TRUE] as $moduleName => $module) {
 418       if ($module->is_active) {
 419         // need an empty array() for all active modules, even if there are no current $declarations
 420         $result[$moduleName] = [];
 421       }
 422     }
 423     foreach ($declarations as $declaration) {
 424       $result[$declaration['module']][$declaration['name']] = $declaration;
 425     }
 426     return $result;
 427   }
 428
 429   /**
 430    * @param $declarations
 431    *
 432    * @return string|bool
 433    *   string on error, or FALSE
 434    */
 435   protected static function validate($declarations) {
 436     foreach ($declarations as $declare) {
 437       foreach (['name', 'module', 'entity', 'params'] as $key) {
 438         if (empty($declare[$key])) {
 439           $str = print_r($declare, TRUE);
 440           return ("Managed Entity is missing field \"$key\": $str");
 441         }
 442       }
 443       // FIXME: validate that each 'module' is known
 444     }
 445     return FALSE;
 446   }
 447
 448   /**
 449    * @param array $declarations
 450    *
 451    * @return array
 452    */
 453   protected static function cleanDeclarations($declarations) {
 454     foreach ($declarations as $name => &$declare) {
 455       if (!array_key_exists('name', $declare)) {
 456         $declare['name'] = $name;
 457       }
 458     }
 459     return $declarations;
 460   }
 461
 462   /**
 463    * @param string $entity
 464    * @param string $action
 465    * @param array $params
 466    * @param array $result
 467    *
 468    * @throws Exception
 469    */
 470   protected function onApiError($entity, $action, $params, $result) {
 471     CRM_Core_Error::debug_var('ManagedEntities_failed', [
 472       'entity' => $entity,
 473       'action' => $action,
 474       'params' => $params,
 475       'result' => $result,
 476     ]);
 477     throw new Exception('API error: ' . $result['error_message']);
 478   }
 479
 480 }