summaryrefslogtreecommitdiff
path: root/hugo/libraries/navigation/Nodes/Node.class.php
diff options
context:
space:
mode:
Diffstat (limited to 'hugo/libraries/navigation/Nodes/Node.class.php')
-rw-r--r--hugo/libraries/navigation/Nodes/Node.class.php444
1 files changed, 444 insertions, 0 deletions
diff --git a/hugo/libraries/navigation/Nodes/Node.class.php b/hugo/libraries/navigation/Nodes/Node.class.php
new file mode 100644
index 0000000..c7593bb
--- /dev/null
+++ b/hugo/libraries/navigation/Nodes/Node.class.php
@@ -0,0 +1,444 @@
+<?php
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * Functionality for the navigation tree in the left frame
+ *
+ * @package PhpMyAdmin-Navigation
+ */
+if (! defined('PHPMYADMIN')) {
+ exit;
+}
+
+/**
+ * The Node is the building block for the collapsible navigation tree
+ *
+ * @package PhpMyAdmin-Navigation
+ */
+class Node
+{
+ /**
+ * @var int Defines a possible node type
+ */
+ const CONTAINER = 0;
+
+ /**
+ * @var int Defines a possible node type
+ */
+ const OBJECT = 1;
+
+ /**
+ * @var string A non-unique identifier for the node
+ * This may be trimmed when grouping nodes
+ */
+ public $name = "";
+
+ /**
+ * @var string A non-unique identifier for the node
+ * This will never change after being assigned
+ */
+ public $real_name = "";
+
+ /**
+ * @var int May be one of CONTAINER or OBJECT
+ */
+ public $type = Node::OBJECT;
+
+ /**
+ * @var bool Whether this object has been created while grouping nodes
+ * Only relevant if the node is of type CONTAINER
+ */
+ public $is_group;
+
+ /**
+ * @var bool Whether to add a "display: none;" CSS
+ * rule to the node when rendering it
+ */
+ public $visible = false;
+
+ /**
+ * @var Node A reference to the parent object of
+ * this node, NULL for the root node.
+ */
+ public $parent;
+
+ /**
+ * @var array An array of Node objects that are
+ * direct children of this node
+ */
+ public $children = array();
+
+ /**
+ * @var Mixed A string used to group nodes, or an array of strings
+ * Only relevant if the node is of type CONTAINER
+ */
+ public $separator = '';
+
+ /**
+ * @var int How many time to recursively apply the grouping function
+ * Only relevant if the node is of type CONTAINER
+ */
+ public $separator_depth = 1;
+
+ /**
+ * @var string An IMG tag, used when rendering the node
+ */
+ public $icon;
+
+ /**
+ * @var Array An array of A tags, used when rendering the node
+ * The indexes in the array may be 'icon' and 'text'
+ */
+ public $links;
+
+ /**
+ * @var string Extra CSS classes for the node
+ */
+ public $classes = '';
+
+ /**
+ * @var string Whether this node is a link for creating new objects
+ */
+ public $isNew = false;
+
+ /**
+ * @var int The position for the pagination of
+ * the branch at the second level of the tree
+ */
+ public $pos2 = 0;
+
+ /**
+ * @var int The position for the pagination of
+ * the branch at the third level of the tree
+ */
+ public $pos3 = 0;
+
+ /**
+ * Initialises the class by setting the mandatory variables
+ *
+ * @param string $name An identifier for the new node
+ * @param int $type Type of node, may be one of CONTAINER or OBJECT
+ * @param bool $is_group Whether this object has been created
+ * while grouping nodes
+ *
+ * @return Node
+ */
+ public function __construct($name, $type = Node::OBJECT, $is_group = false)
+ {
+ if (! empty($name)) {
+ $this->name = $name;
+ $this->real_name = $name;
+ }
+ if ($type === Node::CONTAINER) {
+ $this->type = Node::CONTAINER;
+ }
+ $this->is_group = (bool)$is_group;
+ }
+
+ /**
+ * Adds a child node to this node
+ *
+ * @param Node $child A child node
+ *
+ * @return nothing
+ */
+ public function addChild($child)
+ {
+ $this->children[] = $child;
+ $child->parent = $this;
+ }
+
+ /**
+ * Returns a child node given it's name
+ *
+ * @param string $name The name of requested child
+ * @param bool $real_name Whether to use the "real_name"
+ * instead of "name" in comparisons
+ *
+ * @return false|Node The requested child node or false,
+ * if the requested node cannot be found
+ */
+ public function getChild($name, $real_name = false)
+ {
+ if ($real_name) {
+ foreach ($this->children as $child) {
+ if ($child->real_name == $name) {
+ return $child;
+ }
+ }
+ } else {
+ foreach ($this->children as $child) {
+ if ($child->name == $name) {
+ return $child;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Removes a child node from this node
+ *
+ * @param string $name The name of child to be removed
+ *
+ * @return nothing
+ */
+ public function removeChild($name)
+ {
+ foreach ($this->children as $key => $child) {
+ if ($child->name == $name) {
+ unset($this->children[$key]);
+ break;
+ }
+ }
+ }
+
+ /**
+ * Retreives the parents for a node
+ *
+ * @param bool $self Whether to include the Node itself in the results
+ * @param bool $containers Whether to include nodes of type CONTAINER
+ * @param bool $groups Whether to include nodes which have $group == true
+ *
+ * @return array An array of parent Nodes
+ */
+ public function parents($self = false, $containers = false, $groups = false)
+ {
+ $parents = array();
+ if ($self
+ && ($this->type != Node::CONTAINER || $containers)
+ && ($this->is_group != true || $groups)
+ ) {
+ $parents[] = $this;
+ $self = false;
+ }
+ $parent = $this->parent;
+ while (isset($parent)) {
+ if ( ($parent->type != Node::CONTAINER || $containers)
+ && ($parent->is_group != true || $groups)
+ ) {
+ $parents[] = $parent;
+ }
+ $parent = $parent->parent;
+ }
+ return $parents;
+ }
+
+ /**
+ * Returns the actual parent of a node. If used twice on an index or columns
+ * node, it will return the table and database nodes. The names of the returned
+ * nodes can be used in SQL queries, etc...
+ *
+ * @return Node
+ */
+ public function realParent()
+ {
+ $retval = $this->parents();
+ if (count($retval) > 0) {
+ return $retval[0];
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * This function checks if the node has children nodes associated with it
+ *
+ * @param bool $count_empty_containers Whether to count empty child
+ * containers as valid children
+ *
+ * @return bool Whether the node has child nodes
+ */
+ public function hasChildren($count_empty_containers = true)
+ {
+ $retval = false;
+ if ($count_empty_containers) {
+ if (count($this->children)) {
+ $retval = true;
+ }
+ } else {
+ foreach ($this->children as $child) {
+ if ($child->type == Node::OBJECT || $child->hasChildren(false)) {
+ $retval = true;
+ break;
+ }
+ }
+ }
+ return $retval;
+ }
+
+ /**
+ * Returns true the node has some siblings (other nodes on the same tree level,
+ * in the same branch), false otherwise. The only exception is for nodes on
+ * the third level of the tree (columns and indexes), for which the function
+ * always returns true. This is because we want to render the containers
+ * for these nodes
+ *
+ * @return bool
+ */
+ public function hasSiblings()
+ {
+ $retval = false;
+ $paths = $this->getPaths();
+ if (count($paths['aPath_clean']) > 3) {
+ $retval = true;
+ } else {
+ foreach ($this->parent->children as $child) {
+ if ($child != $this
+ && ($child->type == Node::OBJECT || $child->hasChildren(false))
+ ) {
+ $retval = true;
+ break;
+ }
+ }
+ }
+ return $retval;
+ }
+
+ /**
+ * Returns the number of child nodes that a node has associated with it
+ *
+ * @return int The number of children nodes
+ */
+ public function numChildren()
+ {
+ $retval = 0;
+ foreach ($this->children as $child) {
+ if ($child->type == Node::OBJECT) {
+ $retval++;
+ } else {
+ $retval += $child->numChildren();
+ }
+ }
+ return $retval;
+ }
+
+ /**
+ * Returns the actual path and the virtual paths for a node
+ * both as clean arrays and base64 encoded strings
+ *
+ * @return array
+ */
+ public function getPaths()
+ {
+ $aPath = array();
+ $aPath_clean = array();
+ foreach ($this->parents(true, true, false) as $parent) {
+ $aPath[] = base64_encode($parent->real_name);
+ $aPath_clean[] = $parent->real_name;
+ }
+ $aPath = implode('.', array_reverse($aPath));
+ $aPath_clean = array_reverse($aPath_clean);
+
+ $vPath = array();
+ $vPath_clean = array();
+ foreach ($this->parents(true, true, true) as $parent) {
+ $vPath[] = base64_encode($parent->name);
+ $vPath_clean[] = $parent->name;
+ }
+ $vPath = implode('.', array_reverse($vPath));
+ $vPath_clean = array_reverse($vPath_clean);
+
+ return array(
+ 'aPath' => $aPath,
+ 'aPath_clean' => $aPath_clean,
+ 'vPath' => $vPath,
+ 'vPath_clean' => $vPath_clean
+ );
+ }
+
+ /**
+ * Returns the names of children of type $type present inside this container
+ * This method is overridden by the Node_Database and Node_Table classes
+ *
+ * @param string $type The type of item we are looking for
+ * ('tables', 'views', etc)
+ * @param int $pos The offset of the list within the results
+ * @param string $searchClause A string used to filter the results of the query
+ *
+ * @return array
+ */
+ public function getData($type, $pos, $searchClause = '')
+ {
+ // @todo obey the DisableIS directive
+ $query = "SELECT `SCHEMA_NAME` ";
+ $query .= "FROM `INFORMATION_SCHEMA`.`SCHEMATA` ";
+ $query .= $this->_getWhereClause($searchClause);
+ $query .= "ORDER BY `SCHEMA_NAME` ASC ";
+ $query .= "LIMIT $pos, {$GLOBALS['cfg']['MaxNavigationItems']}";
+ return PMA_DBI_fetch_result($query);
+ }
+
+ /**
+ * Returns the number of children of type $type present inside this container
+ * This method is overridden by the Node_Database and Node_Table classes
+ *
+ * @param string $type The type of item we are looking for
+ * ('tables', 'views', etc)
+ * @param string $searchClause A string used to filter the results of the query
+ *
+ * @return int
+ */
+ public function getPresence($type = '', $searchClause = '')
+ {
+ if (! $GLOBALS['cfg']['Servers'][$GLOBALS['server']]['DisableIS']) {
+ $query = "SELECT COUNT(*) ";
+ $query .= "FROM `INFORMATION_SCHEMA`.`SCHEMATA` ";
+ $query .= $this->_getWhereClause($searchClause);
+ $retval = (int)PMA_DBI_fetch_value($query);
+ } else {
+ $query = "SHOW DATABASES ";
+ if (! empty($searchClause)) {
+ $query .= "LIKE '%";
+ $query .= PMA_Util::sqlAddSlashes(
+ $searchClause, true
+ );
+ $query .= "%' ";
+ }
+ $retval = PMA_DBI_num_rows(PMA_DBI_try_query($query));
+ }
+ return $retval;
+ }
+
+ /**
+ * Returns the WHERE clause depending on the $searchClause parameter
+ * and the hide_db directive
+ *
+ * @param string $searchClause A string used to filter the results of the query
+ *
+ * @return string
+ */
+ private function _getWhereClause($searchClause = '')
+ {
+ $whereClause = "WHERE TRUE ";
+ if (! empty($searchClause)) {
+ $whereClause .= "AND `SCHEMA_NAME` LIKE '%";
+ $whereClause .= PMA_Util::sqlAddSlashes(
+ $searchClause, true
+ );
+ $whereClause .= "%' ";
+ }
+
+ if (! empty($GLOBALS['cfg']['Server']['hide_db'])) {
+ $whereClause .= "AND `SCHEMA_NAME` NOT REGEXP '"
+ . $GLOBALS['cfg']['Server']['hide_db'] . "' ";
+ }
+
+ if (! empty($GLOBALS['cfg']['Server']['only_db'])) {
+ if (is_string($GLOBALS['cfg']['Server']['only_db'])) {
+ $GLOBALS['cfg']['Server']['only_db'] = array(
+ $GLOBALS['cfg']['Server']['only_db']
+ );
+ }
+ $whereClause .= "AND (";
+ $subClauses = array();
+ foreach ($GLOBALS['cfg']['Server']['only_db'] as $each_only_db) {
+ $subClauses[] = " `SCHEMA_NAME` LIKE '"
+ . $each_only_db . "' ";
+ }
+ $whereClause .= implode("OR", $subClauses) . ")";
+ }
+ return $whereClause;
+ }
+
+}
+?>
generated by cgit v1.0-28-g1787 at 2026-01-09 07:57:12 +0000