CRM/Core/Menu.php

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