CRM/Core/Menu.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 /**
  13  * This file contains the various menus of the CiviCRM module
  14  *
  15  * @package CRM
  16  * @copyright CiviCRM LLC https://civicrm.org/licensing
  17  */
  18
  19 require_once 'CRM/Core/I18n.php';
  20
  21 /**
  22  * Class CRM_Core_Menu.
  23  */
  24 class CRM_Core_Menu {
  25
  26   /**
  27    * The list of menu items.
  28    *
  29    * @var array
  30    */
  31   public static $_items = NULL;
  32
  33   /**
  34    * The list of permissioned menu items.
  35    *
  36    * @var array
  37    */
  38   public static $_permissionedItems = NULL;
  39
  40   public static $_serializedElements = array(
  41     'access_arguments',
  42     'access_callback',
  43     'page_arguments',
  44     'page_callback',
  45     'breadcrumb',
  46   );
  47
  48   public static $_menuCache = NULL;
  49   const MENU_ITEM = 1;
  50
  51   /**
  52    * This function fetches the menu items from xml and xmlMenu hooks.
  53    *
  54    * @param bool $fetchFromXML
  55    *   Fetch the menu items from xml and not from cache.
  56    *
  57    * @return array
  58    */
  59   public static function &xmlItems($fetchFromXML = FALSE) {
  60     if (!self::$_items || $fetchFromXML) {
  61       $config = CRM_Core_Config::singleton();
  62
  63       // We needs this until Core becomes a component
  64       $coreMenuFilesNamespace = 'CRM_Core_xml_Menu';
  65       $coreMenuFilesPath = str_replace('_', DIRECTORY_SEPARATOR, $coreMenuFilesNamespace);
  66       global $civicrm_root;
  67       $files = CRM_Utils_File::getFilesByExtension($civicrm_root . DIRECTORY_SEPARATOR . $coreMenuFilesPath, 'xml');
  68
  69       // Grab component menu files
  70       $files = array_merge($files,
  71         CRM_Core_Component::xmlMenu()
  72       );
  73
  74       // lets call a hook and get any additional files if needed
  75       CRM_Utils_Hook::xmlMenu($files);
  76
  77       self::$_items = [];
  78       foreach ($files as $file) {
  79         self::read($file, self::$_items);
  80       }
  81
  82       CRM_Utils_Hook::alterMenu(self::$_items);
  83     }
  84
  85     return self::$_items;
  86   }
  87
  88   /**
  89    * Read menu.
  90    *
  91    * @param string $name
  92    *   File name
  93    * @param array $menu
  94    *   An alterable list of menu items.
  95    *
  96    * @throws Exception
  97    */
  98   public static function read($name, &$menu) {
  99     $xml = simplexml_load_string(file_get_contents($name));
 100     self::readXML($xml, $menu);
 101   }
 102
 103   /**
 104    * @param SimpleXMLElement $xml
 105    *   An XML document defining a list of menu items.
 106    * @param array $menu
 107    *   An alterable list of menu items.
 108    *
 109    * @throws CRM_Core_Exception
 110    */
 111   public static function readXML($xml, &$menu) {
 112     $config = CRM_Core_Config::singleton();
 113     foreach ($xml->item as $item) {
 114       if (!(string ) $item->path) {
 115         CRM_Core_Error::debug('i', $item);
 116         throw new CRM_Core_Exception('Unable to read XML file');
 117       }
 118       $path = (string ) $item->path;
 119       $menu[$path] = [];
 120       unset($item->path);
 121
 122       if ($item->ids_arguments) {
 123         $ids = [];
 124         foreach (array('json' => 'json', 'html' => 'html', 'exception' => 'exceptions') as $tag => $attr) {
 125           $ids[$attr] = [];
 126           foreach ($item->ids_arguments->{$tag} as $value) {
 127             $ids[$attr][] = (string) $value;
 128           }
 129         }
 130         $menu[$path]['ids_arguments'] = $ids;
 131         unset($item->ids_arguments);
 132       }
 133
 134       foreach ($item as $key => $value) {
 135         $key = (string ) $key;
 136         $value = (string ) $value;
 137         if (strpos($key, '_callback') &&
 138           strpos($value, '::')
 139         ) {
 140           // FIXME Remove the rewrite at this level. Instead, change downstream call_user_func*($value)
 141           // to call_user_func*(Civi\Core\Resolver::singleton()->get($value)).
 142           $value = explode('::', $value);
 143         }
 144         elseif ($key == 'access_arguments') {
 145           // FIXME Move the permission parser to its own class (or *maybe* CRM_Core_Permission).
 146           if (strpos($value, ',') ||
 147             strpos($value, ';')
 148           ) {
 149             if (strpos($value, ',')) {
 150               $elements = explode(',', $value);
 151               $op = 'and';
 152             }
 153             else {
 154               $elements = explode(';', $value);
 155               $op = 'or';
 156             }
 157             $items = [];
 158             foreach ($elements as $element) {
 159               $items[] = $element;
 160             }
 161             $value = array($items, $op);
 162           }
 163           else {
 164             $value = array(array($value), 'and');
 165           }
 166         }
 167         elseif ($key == 'is_public' || $key == 'is_ssl') {
 168           $value = ($value == 'true' || $value == 1) ? 1 : 0;
 169         }
 170         $menu[$path][$key] = $value;
 171       }
 172     }
 173   }
 174
 175   /**
 176    * This function defines information for various menu items.
 177    *
 178    * @param bool $fetchFromXML
 179    *   Fetch the menu items from xml and not from cache.
 180    *
 181    * @return array
 182    */
 183   public static function &items($fetchFromXML = FALSE) {
 184     return self::xmlItems($fetchFromXML);
 185   }
 186
 187   /**
 188    * Is array true (whatever that means!).
 189    *
 190    * @param array $values
 191    *
 192    * @return bool
 193    */
 194   public static function isArrayTrue(&$values) {
 195     foreach ($values as $name => $value) {
 196       if (!$value) {
 197         return FALSE;
 198       }
 199     }
 200     return TRUE;
 201   }
 202
 203   /**
 204    * Fill menu values.
 205    *
 206    * @param array $menu
 207    * @param string $path
 208    *
 209    * @throws CRM_Core_Exception
 210    */
 211   public static function fillMenuValues(&$menu, $path) {
 212     $fieldsToPropagate = array(
 213       'access_callback',
 214       'access_arguments',
 215       'page_callback',
 216       'page_arguments',
 217       'is_ssl',
 218     );
 219     $fieldsPresent = [];
 220     foreach ($fieldsToPropagate as $field) {
 221       $fieldsPresent[$field] = isset($menu[$path][$field]);
 222     }
 223
 224     $args = explode('/', $path);
 225     while (!self::isArrayTrue($fieldsPresent) && !empty($args)) {
 226
 227       array_pop($args);
 228       $parentPath = implode('/', $args);
 229
 230       foreach ($fieldsToPropagate as $field) {
 231         if (!$fieldsPresent[$field]) {
 232           $fieldInParentMenu = $menu[$parentPath][$field] ?? NULL;
 233           if ($fieldInParentMenu !== NULL) {
 234             $fieldsPresent[$field] = TRUE;
 235             $menu[$path][$field] = $fieldInParentMenu;
 236           }
 237         }
 238       }
 239     }
 240
 241     if (self::isArrayTrue($fieldsPresent)) {
 242       return;
 243     }
 244
 245     $messages = [];
 246     foreach ($fieldsToPropagate as $field) {
 247       if (!$fieldsPresent[$field]) {
 248         $messages[] = ts("Could not find %1 in path tree",
 249           [1 => $field]
 250         );
 251       }
 252     }
 253     throw new CRM_Core_Exception("'$path': " . implode(', ', $messages));
 254   }
 255
 256   /**
 257    * We use this function to.
 258    *
 259    * 1. Compute the breadcrumb
 260    * 2. Compute local tasks value if any
 261    * 3. Propagate access argument, access callback, page callback to the menu item
 262    * 4. Build the global navigation block
 263    *
 264    * @param array $menu
 265    */
 266   public static function build(&$menu) {
 267     foreach ($menu as $path => $menuItems) {
 268       try {
 269         self::buildBreadcrumb($menu, $path);
 270         self::fillMenuValues($menu, $path);
 271         self::fillComponentIds($menu, $path);
 272         self::buildReturnUrl($menu, $path);
 273
 274         // add add page_type if not present
 275         if (!isset($menu[$path]['page_type'])) {
 276           $menu[$path]['page_type'] = 0;
 277         }
 278       }
 279       catch (CRM_Core_Exception $e) {
 280         Civi::log()->error('Menu path skipped:' . $e->getMessage());
 281       }
 282     }
 283
 284     self::buildAdminLinks($menu);
 285   }
 286
 287   /**
 288    * This function recomputes menu from xml and populates civicrm_menu.
 289    *
 290    * @param bool $truncate
 291    */
 292   public static function store($truncate = TRUE) {
 293     // first clean up the db
 294     if ($truncate) {
 295       $query = 'TRUNCATE civicrm_menu';
 296       CRM_Core_DAO::executeQuery($query);
 297     }
 298     $menuArray = self::items($truncate);
 299
 300     self::build($menuArray);
 301
 302     $daoFields = CRM_Core_DAO_Menu::fields();
 303
 304     foreach ($menuArray as $path => $item) {
 305       $menu = new CRM_Core_DAO_Menu();
 306       $menu->path = $path;
 307       $menu->domain_id = CRM_Core_Config::domainID();
 308
 309       $menu->find(TRUE);
 310
 311       if (!CRM_Core_Config::isUpgradeMode() ||
 312         CRM_Core_BAO_SchemaHandler::checkIfFieldExists('civicrm_menu', 'module_data', FALSE)
 313       ) {
 314         // Move unrecognized fields to $module_data.
 315         $module_data = [];
 316         foreach (array_keys($item) as $key) {
 317           if (!isset($daoFields[$key])) {
 318             $module_data[$key] = $item[$key];
 319             unset($item[$key]);
 320           }
 321         }
 322
 323         $menu->module_data = serialize($module_data);
 324       }
 325
 326       $menu->copyValues($item);
 327
 328       foreach (self::$_serializedElements as $element) {
 329         if (!isset($item[$element]) ||
 330           $item[$element] == 'null'
 331         ) {
 332           $menu->$element = NULL;
 333         }
 334         else {
 335           $menu->$element = serialize($item[$element]);
 336         }
 337       }
 338
 339       $menu->save();
 340     }
 341   }
 342
 343   /**
 344    * Build admin links.
 345    *
 346    * @param array $menu
 347    */
 348   public static function buildAdminLinks(&$menu) {
 349     $values = [];
 350
 351     foreach ($menu as $path => $item) {
 352       if (empty($item['adminGroup'])) {
 353         continue;
 354       }
 355
 356       $query = !empty($item['path_arguments']) ? str_replace(',', '&', $item['path_arguments']) . '&reset=1' : 'reset=1';
 357
 358       $value = array(
 359         'title' => $item['title'],
 360         'desc' => $item['desc'] ?? NULL,
 361         'id' => strtr($item['title'], array(
 362           '(' => '_',
 363           ')' => '',
 364           ' ' => '',
 365           ',' => '_',
 366           '/' => '_',
 367         )),
 368         'url' => CRM_Utils_System::url($path, $query,
 369           FALSE,
 370           NULL,
 371           TRUE,
 372           FALSE,
 373           // forceBackend; CRM-14439 work-around; acceptable for now because we don't display breadcrumbs on frontend
 374           TRUE
 375         ),
 376         'icon' => $item['icon'] ?? NULL,
 377         'extra' => $item['extra'] ?? NULL,
 378       );
 379       if (!array_key_exists($item['adminGroup'], $values)) {
 380         $values[$item['adminGroup']] = [];
 381         $values[$item['adminGroup']]['fields'] = [];
 382       }
 383       $values[$item['adminGroup']]['fields']["{weight}.{$item['title']}"] = $value;
 384       $values[$item['adminGroup']]['component_id'] = $item['component_id'];
 385     }
 386
 387     foreach ($values as $group => $dontCare) {
 388       ksort($values[$group]);
 389     }
 390
 391     $menu['admin'] = array('breadcrumb' => $values);
 392   }
 393
 394   /**
 395    * Get admin links.
 396    *
 397    * @return null
 398    */
 399   public static function &getAdminLinks() {
 400     $links = self::get('admin');
 401
 402     if (!$links ||
 403       !isset($links['breadcrumb'])
 404     ) {
 405       return NULL;
 406     }
 407
 408     $values = &$links['breadcrumb'];
 409     return $values;
 410   }
 411
 412   /**
 413    * Get the breadcrumb for a given path.
 414    *
 415    * @param array $menu
 416    *   An array of all the menu items.
 417    * @param string $path
 418    *   Path for which breadcrumb is to be build.
 419    *
 420    * @return array
 421    *   The breadcrumb for this path
 422    */
 423   public static function buildBreadcrumb(&$menu, $path) {
 424     $crumbs = [];
 425
 426     $pathElements = explode('/', $path);
 427     array_pop($pathElements);
 428
 429     $currentPath = NULL;
 430     while ($newPath = array_shift($pathElements)) {
 431       $currentPath = $currentPath ? ($currentPath . '/' . $newPath) : $newPath;
 432
 433       // when we come across breadcrumb which involves ids,
 434       // we should skip now and later on append dynamically.
 435       if (isset($menu[$currentPath]['skipBreadcrumb'])) {
 436         continue;
 437       }
 438
 439       // add to crumb, if current-path exists in params.
 440       if (array_key_exists($currentPath, $menu) &&
 441         isset($menu[$currentPath]['title'])
 442       ) {
 443         $urlVar = !empty($menu[$currentPath]['path_arguments']) ? '&' . $menu[$currentPath]['path_arguments'] : '';
 444         $crumbs[] = array(
 445           'title' => $menu[$currentPath]['title'],
 446           'url' => CRM_Utils_System::url($currentPath,
 447             'reset=1' . $urlVar,
 448             // absolute
 449             FALSE,
 450             // fragment
 451             NULL,
 452             // htmlize
 453             TRUE,
 454             // frontend
 455             FALSE,
 456             // forceBackend; CRM-14439 work-around; acceptable for now because we don't display breadcrumbs on frontend
 457             TRUE
 458           ),
 459         );
 460       }
 461     }
 462     $menu[$path]['breadcrumb'] = $crumbs;
 463
 464     return $crumbs;
 465   }
 466
 467   /**
 468    * @param $menu
 469    * @param $path
 470    */
 471   public static function buildReturnUrl(&$menu, $path) {
 472     if (!isset($menu[$path]['return_url'])) {
 473       [$menu[$path]['return_url'], $menu[$path]['return_url_args']] = self::getReturnUrl($menu, $path);
 474     }
 475   }
 476
 477   /**
 478    * @param $menu
 479    * @param $path
 480    *
 481    * @return array
 482    */
 483   public static function getReturnUrl(&$menu, $path) {
 484     if (!isset($menu[$path]['return_url'])) {
 485       $pathElements = explode('/', $path);
 486       array_pop($pathElements);
 487
 488       if (empty($pathElements)) {
 489         return array(NULL, NULL);
 490       }
 491       $newPath = implode('/', $pathElements);
 492
 493       return self::getReturnUrl($menu, $newPath);
 494     }
 495     else {
 496       return array(
 497         CRM_Utils_Array::value('return_url',
 498           $menu[$path]
 499         ),
 500         CRM_Utils_Array::value('return_url_args',
 501           $menu[$path]
 502         ),
 503       );
 504     }
 505   }
 506
 507   /**
 508    * @param $menu
 509    * @param $path
 510    *
 511    * @throws \CRM_Core_Exception
 512    */
 513   public static function fillComponentIds(&$menu, $path) {
 514     static $cache = [];
 515
 516     if (array_key_exists('component_id', $menu[$path])) {
 517       return;
 518     }
 519
 520     $args = explode('/', $path);
 521
 522     if (count($args) > 1) {
 523       $compPath = $args[0] . '/' . $args[1];
 524     }
 525     else {
 526       $compPath = $args[0];
 527     }
 528
 529     $componentId = NULL;
 530
 531     if (array_key_exists($compPath, $cache)) {
 532       $menu[$path]['component_id'] = $cache[$compPath];
 533     }
 534     else {
 535       if (!empty($menu[$compPath]['component'])) {
 536         $componentId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_Component',
 537           $menu[$compPath]['component'],
 538           'id', 'name'
 539         );
 540       }
 541       $menu[$path]['component_id'] = $componentId ? $componentId : NULL;
 542       $cache[$compPath] = $menu[$path]['component_id'];
 543     }
 544   }
 545
 546   /**
 547    * @param $path string
 548    *   Path of menu item to retrieve.
 549    *
 550    * @return array
 551    *   Menu entry array.
 552    */
 553   public static function get($path) {
 554     // return null if menu rebuild
 555     $config = CRM_Core_Config::singleton();
 556
 557     $args = explode('/', $path);
 558
 559     $elements = [];
 560     while (!empty($args)) {
 561       $string = implode('/', $args);
 562       $string = CRM_Core_DAO::escapeString($string);
 563       $elements[] = "'{$string}'";
 564       array_pop($args);
 565     }
 566
 567     $queryString = implode(', ', $elements);
 568     $domainID = CRM_Core_Config::domainID();
 569
 570     $query = "
 571 (
 572   SELECT *
 573   FROM     civicrm_menu
 574   WHERE    path in ( $queryString )
 575            AND domain_id = $domainID
 576   ORDER BY length(path) DESC
 577   LIMIT    1
 578 )
 579 ";
 580
 581     if ($path != 'navigation') {
 582       $query .= "
 583 UNION (
 584   SELECT *
 585   FROM   civicrm_menu
 586   WHERE  path IN ( 'navigation' )
 587          AND domain_id = $domainID
 588 )
 589 ";
 590     }
 591
 592     $menu = new CRM_Core_DAO_Menu();
 593     $menu->query($query);
 594
 595     self::$_menuCache = [];
 596     $menuPath = NULL;
 597     while ($menu->fetch()) {
 598       self::$_menuCache[$menu->path] = [];
 599       CRM_Core_DAO::storeValues($menu, self::$_menuCache[$menu->path]);
 600
 601       // Move module_data into main item.
 602       if (isset(self::$_menuCache[$menu->path]['module_data'])) {
 603         CRM_Utils_Array::extend(self::$_menuCache[$menu->path],
 604           CRM_Utils_String::unserialize(self::$_menuCache[$menu->path]['module_data']));
 605         unset(self::$_menuCache[$menu->path]['module_data']);
 606       }
 607
 608       // Unserialize other elements.
 609       foreach (self::$_serializedElements as $element) {
 610         self::$_menuCache[$menu->path][$element] = CRM_Utils_String::unserialize($menu->$element);
 611
 612         if (strpos($path, $menu->path) !== FALSE) {
 613           $menuPath = &self::$_menuCache[$menu->path];
 614         }
 615       }
 616     }
 617
 618     if (strstr($path, 'report/instance')) {
 619       $args = explode('/', $path);
 620       if (is_numeric(end($args))) {
 621         $menuPath['path'] .= '/' . end($args);
 622       }
 623     }
 624
 625     // *FIXME* : hack for 4.1 -> 4.2 upgrades.
 626     if (preg_match('/^civicrm\/(upgrade\/)?queue\//', $path)) {
 627       CRM_Queue_Menu::alter($path, $menuPath);
 628     }
 629
 630     // Part of upgrade framework but not run inside main upgrade because it deletes data
 631     // Once we have another example of a 'cleanup' we should generalize the clause below so it grabs string
 632     // which follows upgrade/ and checks for existence of a function in Cleanup class.
 633     if ($path == 'civicrm/upgrade/cleanup425') {
 634       $menuPath['page_callback'] = array('CRM_Upgrade_Page_Cleanup', 'cleanup425');
 635       $menuPath['access_arguments'][0][] = 'administer CiviCRM';
 636       $menuPath['access_callback'] = array('CRM_Core_Permission', 'checkMenu');
 637     }
 638
 639     if (!empty($menuPath)) {
 640       $i18n = CRM_Core_I18n::singleton();
 641       $i18n->localizeTitles($menuPath);
 642     }
 643     return $menuPath;
 644   }
 645
 646   /**
 647    * @param $pathArgs
 648    *
 649    * @return mixed
 650    */
 651   public static function getArrayForPathArgs($pathArgs) {
 652     if (!is_string($pathArgs)) {
 653       return;
 654     }
 655     $args = [];
 656
 657     $elements = explode(',', $pathArgs);
 658     foreach ($elements as $keyVal) {
 659       list($key, $val) = explode('=', $keyVal, 2);
 660       $arr[$key] = $val;
 661     }
 662
 663     if (array_key_exists('urlToSession', $arr)) {
 664       $urlToSession = [];
 665
 666       $params = explode(';', $arr['urlToSession']);
 667       $count = 0;
 668       foreach ($params as $keyVal) {
 669         list($urlToSession[$count]['urlVar'],
 670           $urlToSession[$count]['sessionVar'],
 671           $urlToSession[$count]['type'],
 672           $urlToSession[$count]['default']
 673           ) = explode(':', $keyVal);
 674         $count++;
 675       }
 676       $arr['urlToSession'] = $urlToSession;
 677     }
 678     return $arr;
 679   }
 680
 681 }