Your IP : 216.73.217.68
home/wuectly/www/plugins/editors-xtd/menu/menu.php 0000604 00000002530 15245557353 0016376 0 ustar 00 <?php
/**
* @package Joomla.Plugin
* @subpackage Editors-xtd.menu
*
* @copyright (C) 2016 Open Source Matters, Inc. <https://www.joomla.org>
* @license GNU General Public License version 2 or later; see LICENSE.txt
*/
defined('_JEXEC') or die;
/**
* Editor menu button
*
* @since 3.7.0
*/
class PlgButtonMenu extends JPlugin
{
/**
* Load the language file on instantiation.
*
* @var boolean
* @since 3.7.0
*/
protected $autoloadLanguage = true;
/**
* Display the button
*
* @param string $name The name of the button to add
*
* @since 3.7.0
* @return array
*/
public function onDisplay($name)
{
/*
* Use the built-in element view to select the menu item.
* Currently uses blank class.
*/
$user = JFactory::getUser();
if ($user->authorise('core.create', 'com_menus')
|| $user->authorise('core.edit', 'com_menus'))
{
$link = 'index.php?option=com_menus&view=items&layout=modal&tmpl=component&'
. JSession::getFormToken() . '=1&editor=' . $name;
$button = new JObject;
$button->modal = true;
$button->class = 'btn';
$button->link = $link;
$button->text = JText::_('PLG_EDITORS-XTD_MENU_BUTTON_MENU');
$button->name = 'share-alt';
$button->options = "{handler: 'iframe', size: {x: 800, y: 500}}";
return $button;
}
}
}
home/wuectly/www/libraries/regularlabs/helpers/assignments/menu.php 0000604 00000004547 15245607071 0021762 0 ustar 00 <?php
/**
* @package Regular Labs Library
* @version 21.4.10972
*
* @author Peter van Westen <info@regularlabs.com>
* @link http://www.regularlabs.com
* @copyright Copyright © 2021 Regular Labs All Rights Reserved
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
*/
/* @DEPRECATED */
defined('_JEXEC') or die;
use Joomla\CMS\Factory as JFactory;
if (is_file(JPATH_LIBRARIES . '/regularlabs/autoload.php'))
{
require_once JPATH_LIBRARIES . '/regularlabs/autoload.php';
}
require_once dirname(__DIR__) . '/assignment.php';
class RLAssignmentsMenu extends RLAssignment
{
public function passMenu()
{
// return if no Itemid or selection is set
if ( ! $this->request->Itemid || empty($this->selection))
{
return $this->pass($this->params->inc_noitemid);
}
$menutype = 'type.' . self::getMenuType();
// return true if menu type is in selection
if (in_array($menutype, $this->selection))
{
return $this->pass(true);
}
// return true if menu is in selection
if (in_array($this->request->Itemid, $this->selection))
{
return $this->pass(($this->params->inc_children != 2));
}
if ( ! $this->params->inc_children)
{
return $this->pass(false);
}
$parent_ids = $this->getMenuParentIds($this->request->Itemid);
$parent_ids = array_diff($parent_ids, [1]);
foreach ($parent_ids as $id)
{
if ( ! in_array($id, $this->selection))
{
continue;
}
return $this->pass(true);
}
return $this->pass(false);
}
private function getMenuParentIds($id = 0)
{
return $this->getParentIds($id, 'menu');
}
private function getMenuType()
{
if (isset($this->request->menutype))
{
return $this->request->menutype;
}
if (empty($this->request->Itemid))
{
$this->request->menutype = '';
return $this->request->menutype;
}
if (JFactory::getApplication()->isClient('site'))
{
$menu = JFactory::getApplication()->getMenu()->getItem((int) $this->request->Itemid);
$this->request->menutype = isset($menu->menutype) ? $menu->menutype : '';
return $this->request->menutype;
}
$query = $this->db->getQuery(true)
->select('m.menutype')
->from('#__menu AS m')
->where('m.id = ' . (int) $this->request->Itemid);
$this->db->setQuery($query);
$this->request->menutype = $this->db->loadResult();
return $this->request->menutype;
}
}
home/wuectly/www/libraries/cms/html/menu.php 0000604 00000023143 15245611147 0015200 0 ustar 00 <?php
/**
* @package Joomla.Libraries
* @subpackage HTML
*
* @copyright (C) 2007 Open Source Matters, Inc. <https://www.joomla.org>
* @license GNU General Public License version 2 or later; see LICENSE.txt
*/
defined('JPATH_PLATFORM') or die;
/**
* Utility class working with menu select lists
*
* @since 1.5
*/
abstract class JHtmlMenu
{
/**
* Cached array of the menus.
*
* @var array
* @since 1.6
*/
protected static $menus = array();
/**
* Cached array of the menus items.
*
* @var array
* @since 1.6
*/
protected static $items = array();
/**
* Get a list of the available menus.
*
* @param int $clientId The client id
*
* @return array
*
* @since 1.6
*/
public static function menus($clientId = 0)
{
$key = serialize($clientId);
if (!isset(static::$menus[$key]))
{
$db = JFactory::getDbo();
$query = $db->getQuery(true)
->select($db->qn(array('id', 'menutype', 'title', 'client_id'), array('id', 'value', 'text', 'client_id')))
->from($db->quoteName('#__menu_types'))
->order('client_id, title');
if (isset($clientId))
{
$query->where('client_id = ' . (int) $clientId);
}
static::$menus[$key] = $db->setQuery($query)->loadObjectList();
}
return static::$menus[$key];
}
/**
* Returns an array of menu items grouped by menu.
*
* @param array $config An array of configuration options [published, checkacl, clientid].
*
* @return array
*
* @since 1.6
*/
public static function menuItems($config = array())
{
$key = serialize($config);
if (empty(static::$items[$key]))
{
// B/C - not passed = 0, null can be passed for both clients
$clientId = array_key_exists('clientid', $config) ? $config['clientid'] : 0;
$menus = static::menus($clientId);
$db = JFactory::getDbo();
$query = $db->getQuery(true)
->select('a.id AS value, a.title AS text, a.level, a.menutype, a.client_id')
->from('#__menu AS a')
->where('a.parent_id > 0');
// Filter on the client id
if (isset($clientId))
{
$query->where('a.client_id = ' . (int) $clientId);
}
// Filter on the published state
if (isset($config['published']))
{
if (is_numeric($config['published']))
{
$query->where('a.published = ' . (int) $config['published']);
}
elseif ($config['published'] === '')
{
$query->where('a.published IN (0,1)');
}
}
$query->order('a.lft');
$db->setQuery($query);
$items = $db->loadObjectList();
// Collate menu items based on menutype
$lookup = array();
foreach ($items as &$item)
{
if (!isset($lookup[$item->menutype]))
{
$lookup[$item->menutype] = array();
}
$lookup[$item->menutype][] = &$item;
// Translate the menu item title when client is administrator
if ($clientId === 1)
{
$item->text = JText::_($item->text);
}
$item->text = str_repeat('- ', $item->level) . $item->text;
}
static::$items[$key] = array();
$user = JFactory::getUser();
$aclcheck = !empty($config['checkacl']) ? (int) $config['checkacl'] : 0;
foreach ($menus as &$menu)
{
if ($aclcheck)
{
$action = $aclcheck == $menu->id ? 'edit' : 'create';
if (!$user->authorise('core.' . $action, 'com_menus.menu.' . $menu->id))
{
continue;
}
}
// Start group:
static::$items[$key][] = JHtml::_('select.optgroup', $menu->text);
// Special "Add to this Menu" option:
static::$items[$key][] = JHtml::_('select.option', $menu->value . '.1', JText::_('JLIB_HTML_ADD_TO_THIS_MENU'));
// Menu items:
if (isset($lookup[$menu->value]))
{
foreach ($lookup[$menu->value] as &$item)
{
static::$items[$key][] = JHtml::_('select.option', $menu->value . '.' . $item->value, $item->text);
}
}
// Finish group:
static::$items[$key][] = JHtml::_('select.optgroup', $menu->text);
}
}
return static::$items[$key];
}
/**
* Displays an HTML select list of menu items.
*
* @param string $name The name of the control.
* @param string $selected The value of the selected option.
* @param string $attribs Attributes for the control.
* @param array $config An array of options for the control [id, published, checkacl, clientid].
*
* @return string
*
* @since 1.6
*/
public static function menuItemList($name, $selected = null, $attribs = null, $config = array())
{
static $count;
$options = static::menuItems($config);
return JHtml::_(
'select.genericlist', $options, $name,
array(
'id' => isset($config['id']) ? $config['id'] : 'assetgroups_' . (++$count),
'list.attr' => $attribs === null ? 'class="inputbox" size="1"' : $attribs,
'list.select' => (int) $selected,
'list.translate' => false,
)
);
}
/**
* Build the select list for Menu Ordering
*
* @param object &$row The row object
* @param integer $id The id for the row. Must exist to enable menu ordering
*
* @return string
*
* @since 1.5
*/
public static function ordering(&$row, $id)
{
if ($id)
{
$db = JFactory::getDbo();
$query = $db->getQuery(true)
->select('ordering AS value, title AS text')
->from($db->quoteName('#__menu'))
->where($db->quoteName('menutype') . ' = ' . $db->quote($row->menutype))
->where($db->quoteName('parent_id') . ' = ' . (int) $row->parent_id)
->where($db->quoteName('published') . ' != -2')
->order('ordering');
$order = JHtml::_('list.genericordering', $query);
$ordering = JHtml::_(
'select.genericlist', $order, 'ordering',
array('list.attr' => 'class="inputbox" size="1"', 'list.select' => (int) $row->ordering)
);
}
else
{
$ordering = '<input type="hidden" name="ordering" value="' . $row->ordering . '" />' . JText::_('JGLOBAL_NEWITEMSLAST_DESC');
}
return $ordering;
}
/**
* Build the multiple select list for Menu Links/Pages
*
* @param boolean $all True if all can be selected
* @param boolean $unassigned True if unassigned can be selected
* @param int $clientId The client id
*
* @return string
*
* @since 1.5
*/
public static function linkOptions($all = false, $unassigned = false, $clientId = 0)
{
$db = JFactory::getDbo();
// Get a list of the menu items
$query = $db->getQuery(true)
->select('m.id, m.parent_id, m.title, m.menutype, m.client_id')
->from($db->quoteName('#__menu') . ' AS m')
->where($db->quoteName('m.published') . ' = 1')
->order('m.client_id, m.menutype, m.parent_id');
if (isset($clientId))
{
$query->where('m.client_id = ' . (int) $clientId);
}
$db->setQuery($query);
$mitems = $db->loadObjectList();
if (!$mitems)
{
$mitems = array();
}
// Establish the hierarchy of the menu
$children = array();
// First pass - collect children
foreach ($mitems as $v)
{
$pt = $v->parent_id;
$list = @$children[$pt] ? $children[$pt] : array();
$list[] = $v;
$children[$pt] = $list;
}
// Second pass - get an indent list of the items
$list = static::treerecurse((int) $mitems[0]->parent_id, '', array(), $children, 9999, 0, 0);
// Code that adds menu name to Display of Page(s)
$mitems = array();
if ($all | $unassigned)
{
$mitems[] = JHtml::_('select.option', '<OPTGROUP>', JText::_('JOPTION_MENUS'));
if ($all)
{
$mitems[] = JHtml::_('select.option', 0, JText::_('JALL'));
}
if ($unassigned)
{
$mitems[] = JHtml::_('select.option', -1, JText::_('JOPTION_UNASSIGNED'));
}
$mitems[] = JHtml::_('select.option', '</OPTGROUP>');
}
$lastMenuType = null;
$tmpMenuType = null;
foreach ($list as $list_a)
{
if ($list_a->menutype != $lastMenuType)
{
if ($tmpMenuType)
{
$mitems[] = JHtml::_('select.option', '</OPTGROUP>');
}
$mitems[] = JHtml::_('select.option', '<OPTGROUP>', $list_a->menutype);
$lastMenuType = $list_a->menutype;
$tmpMenuType = $list_a->menutype;
}
$mitems[] = JHtml::_('select.option', $list_a->id, $list_a->title);
}
if ($lastMenuType !== null)
{
$mitems[] = JHtml::_('select.option', '</OPTGROUP>');
}
return $mitems;
}
/**
* Build the list representing the menu tree
*
* @param integer $id Id of the menu item
* @param string $indent The indentation string
* @param array $list The list to process
* @param array &$children The children of the current item
* @param integer $maxlevel The maximum number of levels in the tree
* @param integer $level The starting level
* @param int $type Set the type of spacer to use. Use 1 for |_ or 0 for -
*
* @return array
*
* @since 1.5
*/
public static function treerecurse($id, $indent, $list, &$children, $maxlevel = 9999, $level = 0, $type = 1)
{
if ($level <= $maxlevel && isset($children[$id]) && is_array($children[$id]))
{
if ($type)
{
$pre = '<sup>|_</sup> ';
$spacer = '.      ';
}
else
{
$pre = '- ';
$spacer = '  ';
}
foreach ($children[$id] as $v)
{
$id = $v->id;
if ($v->parent_id == 0)
{
$txt = $v->title;
}
else
{
$txt = $pre . $v->title;
}
$list[$id] = $v;
$list[$id]->treename = $indent . $txt;
if (isset($children[$id]) && is_array($children[$id]))
{
$list[$id]->children = count($children[$id]);
$list = static::treerecurse($id, $indent . $spacer, $list, $children, $maxlevel, $level + 1, $type);
}
else
{
$list[$id]->children = 0;
}
}
}
return $list;
}
}
home/wuectly/www/administrator/components/com_menus/models/menu.php 0000604 00000020602 15245703272 0022011 0 ustar 00 <?php
/**
* @package Joomla.Administrator
* @subpackage com_menus
*
* @copyright (C) 2006 Open Source Matters, Inc. <https://www.joomla.org>
* @license GNU General Public License version 2 or later; see LICENSE.txt
*/
defined('_JEXEC') or die;
use Joomla\Registry\Registry;
use Joomla\Utilities\ArrayHelper;
/**
* Menu Item Model for Menus.
*
* @since 1.6
*/
class MenusModelMenu extends JModelForm
{
/**
* The prefix to use with controller messages.
*
* @var string
* @since 1.6
*/
protected $text_prefix = 'COM_MENUS_MENU';
/**
* Model context string.
*
* @var string
*/
protected $_context = 'com_menus.menu';
/**
* Method to test whether a record can be deleted.
*
* @param object $record A record object.
*
* @return boolean True if allowed to delete the record. Defaults to the permission set in the component.
*
* @since 1.6
*/
protected function canDelete($record)
{
return JFactory::getUser()->authorise('core.delete', 'com_menus.menu.' . (int) $record->id);
}
/**
* Method to test whether the state of a record can be edited.
*
* @param object $record A record object.
*
* @return boolean True if allowed to change the state of the record. Defaults to the permission set in the component.
*
* @since 1.6
*/
protected function canEditState($record)
{
$user = JFactory::getUser();
return $user->authorise('core.edit.state', 'com_menus.menu.' . (int) $record->id);
}
/**
* Returns a Table object, always creating it
*
* @param string $type The table type to instantiate
* @param string $prefix A prefix for the table class name. Optional.
* @param array $config Configuration array for model. Optional.
*
* @return JTable A database object
*
* @since 1.6
*/
public function getTable($type = 'MenuType', $prefix = 'JTable', $config = array())
{
return JTable::getInstance($type, $prefix, $config);
}
/**
* Auto-populate the model state.
*
* Note. Calling getState in this method will result in recursion.
*
* @return void
*
* @since 1.6
*/
protected function populateState()
{
$app = JFactory::getApplication('administrator');
// Load the User state.
$id = $app->input->getInt('id');
$this->setState('menu.id', $id);
// Load the parameters.
$params = JComponentHelper::getParams('com_menus');
$this->setState('params', $params);
}
/**
* Method to get a menu item.
*
* @param integer $itemId The id of the menu item to get.
*
* @return mixed Menu item data object on success, false on failure.
*
* @since 1.6
*/
public function &getItem($itemId = null)
{
$itemId = (!empty($itemId)) ? $itemId : (int) $this->getState('menu.id');
// Get a menu item row instance.
$table = $this->getTable();
// Attempt to load the row.
$return = $table->load($itemId);
// Check for a table object error.
if ($return === false && $table->getError())
{
$this->setError($table->getError());
return false;
}
$properties = $table->getProperties(1);
$value = ArrayHelper::toObject($properties, 'JObject');
return $value;
}
/**
* Method to get the menu item form.
*
* @param array $data Data for the form.
* @param boolean $loadData True if the form is to load its own data (default case), false if not.
*
* @return JForm A JForm object on success, false on failure
*
* @since 1.6
*/
public function getForm($data = array(), $loadData = true)
{
// Get the form.
$form = $this->loadForm('com_menus.menu', 'menu', array('control' => 'jform', 'load_data' => $loadData));
if (empty($form))
{
return false;
}
return $form;
}
/**
* Method to get the data that should be injected in the form.
*
* @return mixed The data for the form.
*
* @since 1.6
*/
protected function loadFormData()
{
// Check the session for previously entered form data.
$data = JFactory::getApplication()->getUserState('com_menus.edit.menu.data', array());
if (empty($data))
{
$data = $this->getItem();
}
else
{
unset($data['preset']);
}
$this->preprocessData('com_menus.menu', $data);
return $data;
}
/**
* Method to validate the form data.
*
* @param JForm $form The form to validate against.
* @param array $data The data to validate.
* @param string $group The name of the field group to validate.
*
* @return array|boolean Array of filtered data if valid, false otherwise.
*
* @see JFormRule
* @see JFilterInput
* @since 3.9.23
*/
public function validate($form, $data, $group = null)
{
if (!JFactory::getUser()->authorise('core.admin', 'com_menus'))
{
if (isset($data['rules']))
{
unset($data['rules']);
}
}
return parent::validate($form, $data, $group);
}
/**
* Method to save the form data.
*
* @param array $data The form data.
*
* @return boolean True on success.
*
* @since 1.6
*/
public function save($data)
{
$dispatcher = JEventDispatcher::getInstance();
$id = (!empty($data['id'])) ? $data['id'] : (int) $this->getState('menu.id');
$isNew = true;
// Get a row instance.
$table = $this->getTable();
// Include the plugins for the save events.
JPluginHelper::importPlugin('content');
// Load the row if saving an existing item.
if ($id > 0)
{
$isNew = false;
$table->load($id);
}
// Bind the data.
if (!$table->bind($data))
{
$this->setError($table->getError());
return false;
}
// Check the data.
if (!$table->check())
{
$this->setError($table->getError());
return false;
}
// Trigger the before event.
$result = $dispatcher->trigger('onContentBeforeSave', array($this->_context, &$table, $isNew));
// Store the data.
if (in_array(false, $result, true) || !$table->store())
{
$this->setError($table->getError());
return false;
}
// Trigger the after save event.
$dispatcher->trigger('onContentAfterSave', array($this->_context, &$table, $isNew));
$this->setState('menu.id', $table->id);
// Clean the cache
$this->cleanCache();
return true;
}
/**
* Method to delete groups.
*
* @param array $itemIds An array of item ids.
*
* @return boolean Returns true on success, false on failure.
*
* @since 1.6
*/
public function delete($itemIds)
{
$dispatcher = JEventDispatcher::getInstance();
// Sanitize the ids.
$itemIds = ArrayHelper::toInteger((array) $itemIds);
// Get a group row instance.
$table = $this->getTable();
// Include the plugins for the delete events.
JPluginHelper::importPlugin('content');
// Iterate the items to delete each one.
foreach ($itemIds as $itemId)
{
if ($table->load($itemId))
{
// Trigger the before delete event.
$result = $dispatcher->trigger('onContentBeforeDelete', array($this->_context, $table));
if (in_array(false, $result, true) || !$table->delete($itemId))
{
$this->setError($table->getError());
return false;
}
// Trigger the after delete event.
$dispatcher->trigger('onContentAfterDelete', array($this->_context, $table));
// TODO: Delete the menu associations - Menu items and Modules
}
}
// Clean the cache
$this->cleanCache();
return true;
}
/**
* Gets a list of all mod_mainmenu modules and collates them by menutype
*
* @return array
*
* @since 1.6
*/
public function &getModules()
{
$db = $this->getDbo();
$query = $db->getQuery(true)
->from('#__modules as a')
->select('a.id, a.title, a.params, a.position')
->where('module = ' . $db->quote('mod_menu'))
->select('ag.title AS access_title')
->join('LEFT', '#__viewlevels AS ag ON ag.id = a.access');
$db->setQuery($query);
$modules = $db->loadObjectList();
$result = array();
foreach ($modules as &$module)
{
$params = new Registry($module->params);
$menuType = $params->get('menutype');
if (!isset($result[$menuType]))
{
$result[$menuType] = array();
}
$result[$menuType][] = & $module;
}
return $result;
}
/**
* Custom clean the cache
*
* @param string $group Cache group name.
* @param integer $clientId Application client id.
*
* @return void
*
* @since 1.6
*/
protected function cleanCache($group = null, $clientId = 0)
{
parent::cleanCache('com_menus', 0);
parent::cleanCache('com_modules');
parent::cleanCache('mod_menu', 0);
parent::cleanCache('mod_menu', 1);
}
}
home/wuectly/www/administrator/modules/mod_menu/menu.php 0000604 00000031476 15245721231 0017635 0 ustar 00 <?php
/**
* @package Joomla.Administrator
* @subpackage mod_menu
*
* @copyright (C) 2006 Open Source Matters, Inc. <https://www.joomla.org>
* @license GNU General Public License version 2 or later; see LICENSE.txt
*/
defined('_JEXEC') or die;
use Joomla\CMS\Factory;
use Joomla\CMS\Log\Log;
use Joomla\CMS\Menu\Node;
use Joomla\CMS\Menu\Tree;
use Joomla\CMS\Menu\MenuHelper;
use Joomla\CMS\User\User;
use Joomla\Registry\Registry;
use Joomla\Utilities\ArrayHelper;
/**
* Tree based class to render the admin menu
*
* @since 1.5
*/
class JAdminCssMenu
{
/**
* The Menu tree object
*
* @var Tree
* @since 3.8.0
* @deprecated 4.0
*/
protected $tree;
/**
* The module options
*
* @var Registry
* @since 3.8.0
*/
protected $params;
/**
* The menu bar state
*
* @var bool
* @since 3.8.0
*/
protected $enabled;
/**
* The current user
*
* @var User
* @since 3.9.1
*/
protected $user;
/**
* JAdminCssMenu constructor.
*
* @param User|null $user The current user
*
* @since 3.9.1
*/
public function __construct(User $user = null)
{
if ($user === null)
{
Log::add(
sprintf(
'Not passing a %s instance into the %s constructor is deprecated. As of 4.0, it will be required.',
'Joomla\CMS\User\User',
__CLASS__
),
Log::WARNING,
'deprecated'
);
$user = Factory::getUser();
}
$this->user = $user;
}
/**
* Get the current menu tree
*
* @return Tree
*
* @since 3.8.0
*
* @deprecated 4.0
*/
public function getTree()
{
if (!$this->tree)
{
$this->tree = new Tree;
}
return $this->tree;
}
/**
* Populate the menu items in the menu tree object
*
* @param Registry $params Menu configuration parameters
* @param bool $enabled Whether the menu should be enabled or disabled
*
* @return void
*
* @since 3.7.0
*/
public function load($params, $enabled)
{
$this->tree = $this->getTree();
$this->params = $params;
$this->enabled = $enabled;
$menutype = $this->params->get('menutype', '*');
if ($menutype === '*')
{
$name = $this->params->get('preset', 'joomla');
$levels = MenuHelper::loadPreset($name);
}
else
{
$items = MenusHelper::getMenuItems($menutype, true);
if ($this->enabled && $this->params->get('check', 1))
{
if ($this->check($items, $this->params))
{
$this->params->set('recovery', true);
// In recovery mode, load the preset inside a special root node.
$this->tree->addChild(new Node\Heading('MOD_MENU_RECOVERY_MENU_ROOT'), true);
$levels = MenuHelper::loadPreset('joomla');
$levels = $this->preprocess($levels);
$this->populateTree($levels);
$this->tree->addChild(new Node\Separator);
// Add link to exit recovery mode
$uri = clone JUri::getInstance();
$uri->setVar('recover_menu', 0);
$this->tree->addChild(new Node\Url('MOD_MENU_RECOVERY_EXIT', $uri->toString()));
$this->tree->getParent();
}
}
$levels = MenuHelper::createLevels($items);
}
$levels = $this->preprocess($levels);
$this->populateTree($levels);
}
/**
* Method to render a given level of a menu using provided layout file
*
* @param string $layoutFile The layout file to be used to render
*
* @return void
*
* @since 3.8.0
*/
public function renderSubmenu($layoutFile)
{
if (is_file($layoutFile))
{
$children = $this->tree->getCurrent()->getChildren();
foreach ($children as $child)
{
$this->tree->setCurrent($child);
// This sets the scope to this object for the layout file and also isolates other `include`s
require $layoutFile;
}
}
}
/**
* Check the flat list of menu items for important links
*
* @param array $items The menu items array
* @param Registry $params Module options
*
* @return boolean Whether to show recovery menu
*
* @since 3.8.0
*/
protected function check($items, Registry $params)
{
$authMenus = $this->user->authorise('core.manage', 'com_menus');
$authModules = $this->user->authorise('core.manage', 'com_modules');
if (!$authMenus && !$authModules)
{
return false;
}
$app = JFactory::getApplication();
$types = ArrayHelper::getColumn($items, 'type');
$elements = ArrayHelper::getColumn($items, 'element');
$rMenu = $authMenus && !in_array('com_menus', $elements);
$rModule = $authModules && !in_array('com_modules', $elements);
$rContainer = !in_array('container', $types);
if ($rMenu || $rModule || $rContainer)
{
$recovery = $app->getUserStateFromRequest('mod_menu.recovery', 'recover_menu', 0, 'int');
if ($recovery)
{
return true;
}
$missing = array();
if ($rMenu)
{
$missing[] = JText::_('MOD_MENU_IMPORTANT_ITEM_MENU_MANAGER');
}
if ($rModule)
{
$missing[] = JText::_('MOD_MENU_IMPORTANT_ITEM_MODULE_MANAGER');
}
if ($rContainer)
{
$missing[] = JText::_('MOD_MENU_IMPORTANT_ITEM_COMPONENTS_CONTAINER');
}
$uri = clone JUri::getInstance();
$uri->setVar('recover_menu', 1);
$table = JTable::getInstance('MenuType');
$menutype = $params->get('menutype');
$table->load(array('menutype' => $menutype));
$menutype = $table->get('title', $menutype);
$message = JText::sprintf('MOD_MENU_IMPORTANT_ITEMS_INACCESSIBLE_LIST_WARNING', $menutype, implode(', ', $missing), $uri);
$app->enqueueMessage($message, 'warning');
}
return false;
}
/**
* Filter and perform other preparatory tasks for loaded menu items based on access rights and module configurations for display
*
* @param \stdClass[] $items The levelled array of menu item objects
*
* @return array
*
* @since 3.8.0
*/
protected function preprocess($items)
{
$result = array();
$language = JFactory::getLanguage();
$noSeparator = true;
// Call preprocess for the menu items on plugins.
// Plugins should normally process the current level only unless their logic needs deep levels too.
$dispatcher = JEventDispatcher::getInstance();
$dispatcher->trigger('onPreprocessMenuItems', array('com_menus.administrator.module', &$items, $this->params, $this->enabled));
foreach ($items as $i => &$item)
{
// Exclude item with menu item option set to exclude from menu modules
if ($item->params->get('menu_show', 1) == 0)
{
continue;
}
$item->scope = isset($item->scope) ? $item->scope : 'default';
$item->icon = isset($item->icon) ? $item->icon : '';
// Whether this scope can be displayed. Applies only to preset items. Db driven items should use un/published state.
if (($item->scope === 'help' && !$this->params->get('showhelp', 1)) || ($item->scope === 'edit' && !$this->params->get('shownew', 1)))
{
continue;
}
if (substr($item->link, 0, 8) === 'special:')
{
$special = substr($item->link, 8);
if ($special === 'language-forum')
{
$item->link = 'index.php?option=com_admin&view=help&layout=langforum';
}
elseif ($special === 'custom-forum')
{
$item->link = $this->params->get('forum_url');
}
}
// Exclude item if is not enabled
if ($item->element && !JComponentHelper::isEnabled($item->element))
{
continue;
}
// Exclude Mass Mail if disabled in global configuration
if ($item->scope === 'massmail' && (JFactory::getApplication()->get('massmailoff', 0) == 1))
{
continue;
}
// Exclude item if the component is not authorised
$assetName = $item->element;
if ($item->element === 'com_categories')
{
parse_str($item->link, $query);
$assetName = isset($query['extension']) ? $query['extension'] : 'com_content';
}
elseif ($item->element === 'com_fields')
{
parse_str($item->link, $query);
// Only display Fields menus when enabled in the component
$createFields = null;
if (isset($query['context']))
{
$createFields = JComponentHelper::getParams(strstr($query['context'], '.', true))->get('custom_fields_enable', 1);
}
if (!$createFields)
{
continue;
}
list($assetName) = isset($query['context']) ? explode('.', $query['context'], 2) : array('com_fields');
}
// Special case for components which only allow super user access
elseif (in_array($item->element, array('com_config', 'com_privacy', 'com_actionlogs'), true) && !$this->user->authorise('core.admin'))
{
continue;
}
elseif ($item->element === 'com_joomlaupdate' && !$this->user->authorise('core.admin'))
{
continue;
}
elseif (($item->link === 'index.php?option=com_installer&view=install' || $item->link === 'index.php?option=com_installer&view=languages')
&& !$this->user->authorise('core.admin'))
{
continue;
}
elseif ($item->element === 'com_admin')
{
parse_str($item->link, $query);
if (isset($query['view']) && $query['view'] === 'sysinfo' && !$this->user->authorise('core.admin'))
{
continue;
}
}
if ($assetName && !$this->user->authorise(($item->scope === 'edit') ? 'core.create' : 'core.manage', $assetName))
{
continue;
}
// Exclude if link is invalid
if (is_null($item->link) || (!in_array($item->type, array('separator', 'heading', 'container')) && trim($item->link) === ''))
{
continue;
}
// Process any children if exists
$item->submenu = $this->preprocess($item->submenu);
// Populate automatic children for container items
if ($item->type === 'container')
{
$exclude = (array) $item->params->get('hideitems') ?: array();
$components = MenusHelper::getMenuItems('main', false, $exclude);
$item->components = MenuHelper::createLevels($components);
$item->components = $this->preprocess($item->components);
$item->components = ArrayHelper::sortObjects($item->components, 'text', 1, false, true);
}
// Exclude if there are no child items under heading or container
if (in_array($item->type, array('heading', 'container')) && empty($item->submenu) && empty($item->components))
{
continue;
}
// Remove repeated and edge positioned separators, It is important to put this check at the end of any logical filtering.
if ($item->type === 'separator')
{
if ($noSeparator)
{
continue;
}
$noSeparator = true;
}
else
{
$noSeparator = false;
}
// Ok we passed everything, load language at last only
if ($item->element)
{
$language->load($item->element . '.sys', JPATH_ADMINISTRATOR, null, false, true) ||
$language->load($item->element . '.sys', JPATH_ADMINISTRATOR . '/components/' . $item->element, null, false, true);
}
if ($item->type === 'separator' && $item->params->get('text_separator') == 0)
{
$item->title = '';
}
$item->text = JText::_($item->title);
$result[$i] = $item;
}
// If last one was a separator remove it too.
if ($noSeparator && isset($i))
{
unset($result[$i]);
}
return $result;
}
/**
* Load the menu items from a hierarchical list of items into the menu tree
*
* @param stdClass[] $levels Menu items as a hierarchical list format
*
* @return void
*
* @since 3.8.0
*
* @deprecated 4.0
*/
protected function populateTree($levels)
{
foreach ($levels as $item)
{
$class = $this->enabled ? $item->class : 'disabled';
if ($item->type === 'separator')
{
$this->tree->addChild(new Node\Separator($item->title));
}
elseif ($item->type === 'heading')
{
// We already excluded heading type menu item with no children.
$this->tree->addChild(new Node\Heading($item->title, $class, null, $item->icon), $this->enabled);
if ($this->enabled)
{
$this->populateTree($item->submenu);
$this->tree->getParent();
}
}
elseif ($item->type === 'url')
{
$cNode = new Node\Url($item->title, $item->link, $item->browserNav, $class, null, $item->icon);
$this->tree->addChild($cNode, $this->enabled);
if ($this->enabled)
{
$this->populateTree($item->submenu);
$this->tree->getParent();
}
}
elseif ($item->type === 'component')
{
$cNode = new Node\Component($item->title, $item->element, $item->link, $item->browserNav, $class, null, $item->icon);
$this->tree->addChild($cNode, $this->enabled);
if ($this->enabled)
{
$this->populateTree($item->submenu);
$this->tree->getParent();
}
}
elseif ($item->type === 'container')
{
// We already excluded container type menu item with no children.
$this->tree->addChild(new Node\Container($item->title, $item->class, null, $item->icon), $this->enabled);
if ($this->enabled)
{
$this->populateTree($item->submenu);
// Add a separator between dynamic menu items and components menu items
if (count($item->submenu) && count($item->components))
{
$this->tree->addChild(new Node\Separator);
}
$this->populateTree($item->components);
$this->tree->getParent();
}
}
}
}
}