TimeTrex/classes/modules/core/FastTree.class.php

<?php
/*********************************************************************************
 *
 * TimeTrex is a Workforce Management program developed by
 * TimeTrex Software Inc. Copyright (C) 2003 - 2021 TimeTrex Software Inc.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License version 3 as published by
 * the Free Software Foundation with the addition of the following permission
 * added to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED
 * WORK IN WHICH THE COPYRIGHT IS OWNED BY TIMETREX, TIMETREX DISCLAIMS THE
 * WARRANTY OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more
 * details.
 *
 *
 * You should have received a copy of the GNU Affero General Public License along
 * with this program; if not, see http://www.gnu.org/licenses or write to the Free
 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 *
 *
 * You can contact TimeTrex headquarters at Unit 22 - 2475 Dobbin Rd. Suite
 * #292 West Kelowna, BC V4T 2E9, Canada or at email address info@timetrex.com.
 *
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License version 3.
 *
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License
 * version 3, these Appropriate Legal Notices must retain the display of the
 * "Powered by TimeTrex" logo. If the display of the logo is not reasonably
 * feasible for technical reasons, the Appropriate Legal Notices must display
 * the words "Powered by TimeTrex".
 *
 ********************************************************************************/


/*
--	  id serial NOT NULL,
CREATE TABLE hierarchy_tree (
	tree_id integer DEFAULT 0 NOT NULL,
	parent_id integer DEFAULT 0 NOT NULL,
	object_id integer DEFAULT 0 NOT NULL,
	left_id bigint DEFAULT 0 NOT NULL,
	right_id bigint DEFAULT 0 NOT NULL
) WITHOUT OIDS;
--Order of the columsn in the below index seem to matter
create index "hierarchy_tree_left_id_right_id" on hierarchy_tree(left_id, right_id);
create index "hierarchy_tree_tree_id_object_id" on hierarchy_tree(tree_id, object_id);
create index "hierarchy_tree_tree_id_parent_id" on hierarchy_tree(tree_id, parent_id);
*/


/**
 * @package Core
 */
class FastTree {
	var $db = null;
	var $table = 'fast_tree';
	var $tree_id = 0;

	var $spacer = 0;

	/**
	 * FastTree constructor.
	 * @param null $options
	 */
	function __construct( $options = null ) {
		//Debug::Text(' Contruct... ', __FILE__, __LINE__, __METHOD__, 10);

		$this->db = $options['db'];
		//Debug::Text(' Setting DB to: '. $options['db'], __FILE__, __LINE__, __METHOD__, 10);

		$this->table = $options['table'];
		//Debug::Text(' Setting Table to: '. $options['table'], __FILE__, __LINE__, __METHOD__, 10);

		if ( isset( $options['tree_id'] ) ) {
			$this->setTree( $options['tree_id'] );
			//$this->tree_id = $options['tree_id'];
			//Debug::Text(' Setting Tree ID to: '. $options['tree_id'], __FILE__, __LINE__, __METHOD__, 10);
		}

		return true;
	}

	/**
	 * @return int
	 */
	function getTree() {
		return $this->tree_id;
	}

	/**
	 * @param string $id UUID
	 * @return bool
	 */
	function setTree( $id ) {
		if ( $id != '' ) {
			//Debug::Text(' Setting Tree ID to: '. $id, __FILE__, __LINE__, __METHOD__, 10);
			$this->tree_id = $id;

			$this->_setupTree();

			return true;
		}

		return false;
	}

	/**
	 * @return bool
	 */
	function _setupTree() {
		//Add the root node if its missing.
		$node_data = $this->getNode( 0 );
		if ( $node_data === false ) {
			Debug::Text( ' Initiating Tree with Root object: ', __FILE__, __LINE__, __METHOD__, 10 );
			$this->add( 0, -1 );

			return true;
		}

		//Debug::Text(' NOT Initiating Tree with Root object: ', __FILE__, __LINE__, __METHOD__, 10);
		return false;
	}

	/**
	 * @return mixed
	 */
	function getRootId() {
		$ph = [
				'tree_id' => $this->tree_id,
		];

		// get all children of this node
		$query = 'SELECT object_id FROM ' . $this->table . ' WHERE tree_id = ? AND parent_id = -1';
		$root_id = $this->db->GetOne( $query, $ph );

		return $root_id;
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getNode( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		//Check to make sure object_id doesn't exceed 32bit integer.
		if ( !is_numeric( $object_id ) || ( $object_id > 2147483647 || $object_id < -2147483648 ) ) {
			Debug::Text( ' aReturning False', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		$ph = [
				'tree_id'   => (int)$this->getTree(),
				'object_id' => (int)$object_id,
		];

		// get all children of this node
		$query = '	SELECT a.object_id, a.parent_id, a.left_id, a.right_id, count(b.object_id)-1 as level
					FROM ' . $this->table . ' a
					LEFT JOIN ' . $this->table . ' b ON a.tree_id = b.tree_id AND a.left_id BETWEEN b.left_id AND b.right_id

					WHERE a.tree_id = ?
						AND a.object_id = ?
					GROUP BY a.object_id, a.left_id, a.object_id, a.parent_id, a.right_id
				';
		$data = $this->db->GetRow( $query, $ph );

		if ( count( $data ) == 0 ) {
			return false;
		}

		return $data;
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getLevel( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		$data = $this->getNode( $object_id );
		if ( $data === false ) {
			return false;
		}

		return $data['level'];
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getRightId( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		$data = $this->getNode( $object_id );
		if ( $data === false ) {
			return false;
		}

		return $data['right_id'];
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getLeftId( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		$data = $this->getNode( $object_id );
		if ( $data === false ) {
			return false;
		}

		return $data['left_id'];
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getParentId( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		$data = $this->getNode( $object_id );
		if ( $data === false ) {
			return false;
		}

		return $data['parent_id'];
	}

	/**
	 * @param bool $object_id
	 * @return bool
	 */
	function rebuildTree( $object_id = false ) {
		Debug::Text( ' Object ID: ' . $object_id, __FILE__, __LINE__, __METHOD__, 10 );

		$this->db->BeginTrans();
		$this->db->SetTransactionMode( 'SERIALIZABLE' ); //Serialize rebuild tree transactions so concurrency issues don't corrupt the tree.

		if ( $object_id === false ) {
			Debug::Text( ' Object ID not specified, using root: ', __FILE__, __LINE__, __METHOD__, 10 );
			$object_id = $this->getRootId();
			$left_id = 1;
		} else {
			Debug::Text( ' Object ID specified: ', __FILE__, __LINE__, __METHOD__, 10 );
			$left_id = $this->getLeftId( $object_id );
		}

		if ( $left_id === false ) {
			Debug::Text( ' Error getting left id: ', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		Debug::Text( ' aObject ID: ' . $object_id . ' - Left ID: ' . $left_id, __FILE__, __LINE__, __METHOD__, 10 );
		$rebuilt = $this->_rebuildTree( $object_id, $left_id );

		if ( $rebuilt === false ) {
			Debug::Text( ' Error rebuilding tree: ', __FILE__, __LINE__, __METHOD__, 10 );
			$this->db->RollBackTrans();

			return false;
		}

		//$this->db->RollBackTrans();

		$this->db->CommitTrans();

		$this->db->SetTransactionMode( '' ); //Restore default transaction mode.

		Debug::Text( ' Tree Rebuilt: ', __FILE__, __LINE__, __METHOD__, 10 );

		return true;
	}

	/**
	 * @param string $object_id UUID
	 * @param string $left_id   UUID
	 * @return bool
	 */
	function _rebuildTree( $object_id, $left_id ) {
		Debug::Text( ' Object ID: ' . $object_id . ' - Left: ' . $left_id, __FILE__, __LINE__, __METHOD__, 10 );

		$ph = [
				'tree_id'   => (int)$this->getTree(),
				'parent_id' => (int)$object_id,
		];

		// get all children of this node
		$query = 'SELECT object_id FROM ' . $this->table . ' WHERE tree_id = ? AND parent_id = ?';
		$rs = $this->db->Execute( $query, $ph );

		if ( !is_object( $rs ) ) {
			Debug::Text( ' Select failed', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		// the right value of this node is the left value + 1 (or more)
		$right_id = ( $left_id + 10 );

		while ( $row = $rs->FetchRow() ) {
			// recursive execution of this function for each
			// child of this node
			// $right is the current right value, which is
			// incremented by the rebuild_tree function
			Debug::Text( ' Right ID: ' . $right_id, __FILE__, __LINE__, __METHOD__, 10 );
			$right_id = $this->_rebuildTree( $row['object_id'], $right_id );

			if ( $right_id === false ) {
				Debug::Text( ' Right was false: ', __FILE__, __LINE__, __METHOD__, 10 );

				return false;
			}
		}

		$ph = [
				'left_id'   => (int)$left_id,
				'right_id'  => (int)$right_id,
				'tree_id'   => (int)$this->getTree(),
				'object_id' => (int)$object_id,
		];

		// we've got the left value, and now that we've processed
		// the children of this node we also know the right value
		$query = 'UPDATE ' . $this->table . ' SET left_id = ?, right_id = ? WHERE tree_id = ? AND object_id = ?';
		$rs = $this->db->Execute( $query, $ph );

		//Use this to help debug concurrency issues.
		//usleep(100000);

		if ( !is_object( $rs ) ) {
			Debug::Text( ' Rebuild Failed... ', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		// return the right value of this node + 1
		return ( $right_id + 1 );
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getAllParents( $object_id ) {
		//Debug::Text(' Object ID: '. $object_id, __FILE__, __LINE__, __METHOD__, 10);

		if ( $object_id === '' ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		$ph = [
				'tree_id'    => (int)$this->getTree(),
				'object_id'  => (int)$object_id,
				'object_id2' => (int)$object_id,
		];

		$query = '
				SELECT		b.object_id
				FROM		' . $this->table . ' as a
				LEFT JOIN ' . $this->table . ' as b ON a.tree_id = b.tree_id AND a.left_id BETWEEN b.left_id AND b.right_id
				WHERE		a.tree_id = ?
					AND		a.object_id = ?
					AND		b.object_id != 0
					AND		b.object_id != ?
				ORDER BY	b.left_id desc
				';

		return $this->db->GetCol( $query, $ph );
	}

	/**
	 * @param string $object_id UUID
	 * @return bool
	 */
	function getChild( $object_id ) {
		if ( !is_numeric( $object_id ) ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		$ph = [
				'tree_id'   => (int)$this->getTree(),
				'object_id' => (int)$object_id,
		];

		Debug::Text( ' Getting Last Child of: ' . $object_id, __FILE__, __LINE__, __METHOD__, 10 );
		//Order by last child first.
		//GetOne() automatically sets LIMIT 1;
		$query = 'SELECT object_id FROM ' . $this->table . ' WHERE tree_id = ? AND parent_id = ? ORDER BY left_id desc';
		$child_id = $this->db->GetOne( $query, $ph );

		//var_dump($child_id);

		return $child_id;
	}

	/**
	 * @param string|bool $object_id UUID
	 * @param bool $recurse
	 * @param int $data_format
	 * @return array|bool
	 */
	function getAllChildren( $object_id = null, $recurse = false, $data_format = 0 ) {
		$original_object_id = $object_id;
		//Debug::Text(' Object ID: '. $object_id .' Recurse: '. $recurse, __FILE__, __LINE__, __METHOD__, 10);

		if ( $object_id === '' ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		if ( $object_id === null || $object_id === false ) {
			$object_id = $this->getRootId();
			Debug::Text( ' Getting Root ID: ' . $object_id, __FILE__, __LINE__, __METHOD__, 10 );
		}

		$node_data = $this->getNode( $object_id );

		if ( $node_data === false ) {
			Debug::Text( ' Getting node data of object id failed.', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}
		//Debug::Text(' Left ID: '. $node_data['left_id'] .' Level: '. $node_data['level'], __FILE__, __LINE__, __METHOD__, 10);

		$query = '
				SELECT		a.object_id, a.parent_id, count(b.object_id) as level
				FROM		' . $this->table . ' a
				LEFT JOIN ' . $this->table . ' b ON a.tree_id = b.tree_id AND a.left_id BETWEEN b.left_id AND b.right_id
				';
		switch ( strtoupper( $recurse ) ) {
			case 'RECURSE':
				$ph = [
						'tree_id'  => $this->getTree(),
						'left_id'  => $node_data['left_id'],
						'right_id' => $node_data['right_id'],
				];

				//Don't use >= <= (use > < ) - instead to not include the parent object.
				//Make sure current node is not included in the result as well. Otherwise we are saying the current node
				//is a child of itself.
				$query .= '
				WHERE		a.tree_id = ?
					AND		b.left_id > ?
					AND		b.right_id <= ?';

				//Exclude the parnet, but only when the passed object is forsure NULL!
				if ( $original_object_id === null || $original_object_id === false ) {
					$ph['object_id'] = $object_id;

					$query .= '
					AND		a.object_id != ?
					';
				}

				break;
			default:
				$ph = [
						'tree_id'   => (int)$this->getTree(),
						'object_id' => (int)$object_id,
				];

				$query .= '
						WHERE a.tree_id = ?
							AND a.parent_id = ?';
		}
		$query .= '
				GROUP BY	a.object_id, a.parent_id, a.left_id
				ORDER BY	a.left_id';

		$rs = $this->db->Execute( $query, $ph );

		$retarr = [];
		while ( $row = $rs->FetchRow() ) {
			if ( $data_format == 1 ) {
				$retarr[$row['object_id']] = $row;
			} else {
				$retarr[$row['object_id']] = $row['level'];
			}
		}

		if ( empty( $retarr ) == false ) {
			//Debug::Arr( $retarr, ' Children: ', __FILE__, __LINE__, __METHOD__, 10);
			return $retarr;
		}

		return false;
	}

	/**
	 * @param string $parent_id UUID
	 * @return array|bool
	 */
	function _getLeftAndRightIds( $parent_id ) {
		Debug::Text( ' getLeftAndRightIds: ' . $parent_id, __FILE__, __LINE__, __METHOD__, 10 );

		$node_data = $this->getNode( $parent_id );

		$parent_left = $node_data['left_id'];
		$parent_right = $node_data['right_id'];

		$child_id = $this->getChild( $parent_id );
		if ( $child_id !== false ) {
			Debug::Text( ' Child found, getting Child data: ' . $child_id, __FILE__, __LINE__, __METHOD__, 10 );
			$child_node_data = $this->getNode( $child_id );
			$child_left_id = $child_node_data['left_id'];
			$child_right_id = $child_node_data['right_id'];
			unset( $child_node_data );
			Debug::Text( ' Child Left ID: ' . $child_left_id, __FILE__, __LINE__, __METHOD__, 10 );
			Debug::Text( ' Child Right ID: ' . $child_right_id, __FILE__, __LINE__, __METHOD__, 10 );
			Debug::Text( ' Parent Right ID: ' . $parent_right, __FILE__, __LINE__, __METHOD__, 10 );

			$left_id = ( $child_right_id + 1 );
			$right_id = ( $child_right_id + 10 );

			if ( $right_id >= $parent_right
					|| $left_id >= $parent_right ) {
				Debug::Text( ' NO CHILD GAP LEFT: ', __FILE__, __LINE__, __METHOD__, 10 );

				return false;
			}
		} else {
			//Nothing yet.

			//Try to keep a large gap for these.
			$left_id = ( $parent_left + 1 );
			$right_id = ( $parent_right - 1 );

			if ( $right_id >= $parent_right
					|| $left_id >= $parent_right ) {
				Debug::Text( ' NO PARENT GAP LEFT: ', __FILE__, __LINE__, __METHOD__, 10 );

				return false;
			}
		}

		Debug::Text( ' Next Left ID: ' . $left_id, __FILE__, __LINE__, __METHOD__, 10 );
		Debug::Text( ' Next Right ID: ' . $right_id, __FILE__, __LINE__, __METHOD__, 10 );

		return [ 'left_id' => (int)$left_id, 'right_id' => (int)$right_id ];
	}

	/**
	 * @param string $parent_id UUID
	 * @return bool
	 */
	function insertGaps( $parent_id ) {
		$this->spacer++;

		Debug::Text( ' Attempting to insert gaps: ' . $this->spacer, __FILE__, __LINE__, __METHOD__, 10 );

		$node_data = $this->getNode( $parent_id );

		if ( $node_data != false ) {
			Debug::Text( ' Inserting gaps: ' . $this->spacer, __FILE__, __LINE__, __METHOD__, 10 );

			$ph = [
					'tree_id'  => $this->getTree(),
					'right_id' => $node_data['right_id'],
			];

			$query = 'UPDATE ' . $this->table . ' SET right_id = right_id + 1000 WHERE tree_id = ? AND right_id >= ?';
			$this->db->Execute( $query, $ph );

			$query = 'UPDATE ' . $this->table . ' SET left_id = left_id + 1000 WHERE tree_id = ? AND left_id > ?';
			$this->db->Execute( $query, $ph );

			return true;
		}
		Debug::Text( ' Node Data Null: ' . $this->spacer, __FILE__, __LINE__, __METHOD__, 10 );

		return false;
	}

	/**
	 * MPTT + Gap add function.
	 * @param string $object_id UUID
	 * @param int $parent_id
	 * @return bool
	 */
	function add( $object_id, $parent_id = 0 ) {
		Debug::Text( ' Object ID: ' . $object_id . ' Parent ID: ' . $parent_id, __FILE__, __LINE__, __METHOD__, 10 );

		if ( !is_numeric( $object_id ) ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		/*
		if ( $object_id == $parent_id ) {
			Debug::Text(' bReturning False...', __FILE__, __LINE__, __METHOD__, 10);
			return FALSE;
		}
		*/
		//$insert_id = $this->db->GenID( $this->table.'_id_seq', 10);

		//Make sure object doesn't exist already
		if ( $this->getNode( $object_id ) !== false ) {
			Debug::Text( ' cReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		$this->db->BeginTrans();

		if ( $parent_id == -1 ) {
			Debug::Text( ' Parent is 0', __FILE__, __LINE__, __METHOD__, 10 );

			$ph = [
					'tree_id' => $this->getTree(),
			];

			$query = 'SELECT object_id FROM ' . $this->table . ' WHERE tree_id = ? AND parent_id = -1';
			$rs = $this->db->Execute( $query, $ph );

			if ( !is_object( $rs ) ) {
				Debug::Text( ' Select failed', __FILE__, __LINE__, __METHOD__, 10 );
				$this->db->RollBackTrans();

				return false;
			}

			if ( $rs->RowCount() > 0 ) {
				Debug::Text( ' A root node already exists', __FILE__, __LINE__, __METHOD__, 10 );
				$this->db->RollBackTrans();

				return false;
			}

			$left_id = 0;

			//Get max right_id, just incase other nodes exist in the tree.
			$ph = [
					'tree_id' => $this->getTree(),
			];

			$query = 'SELECT max(right_id) as right_id FROM ' . $this->table . ' WHERE tree_id = ?';
			$right_id = ( $this->db->GetOne( $query, $ph ) + 1000 );
		} else {
			Debug::Text( ' Parent IS NOT 0', __FILE__, __LINE__, __METHOD__, 10 );

			$left_and_right_ids = $this->_getLeftAndRightIds( $parent_id );

			if ( $left_and_right_ids === false ) {
				$this->insertGaps( $parent_id );
				$left_and_right_ids = $this->_getLeftAndRightIds( $parent_id );
			}

			$left_id = $left_and_right_ids['left_id'];
			$right_id = $left_and_right_ids['right_id'];
		}

		if ( is_numeric( $this->getTree() )
				&& is_numeric( $parent_id )
				&& is_numeric( $object_id )
				&& is_numeric( $left_id )
				&& is_numeric( $right_id ) ) {
			$ph = [
					'tree_id'   => (int)$this->getTree(),
					'parent_id' => (int)$parent_id,
					'object_id' => (int)$object_id,
					'left_id'   => (int)$left_id,
					'right_id'  => (int)$right_id,
			];

			Debug::Text( ' Inserting Node... Left ID: ' . $left_id . ' Right ID: ' . $right_id, __FILE__, __LINE__, __METHOD__, 10 );
			$query = 'INSERT INTO ' . $this->table . ' (tree_id, parent_id, object_id, left_id, right_id) VALUES (?, ?, ?, ?, ?)';
			$rs = $this->db->Execute( $query, $ph );

			if ( !is_object( $rs ) ) {
				Debug::Text( ' Error inserting node', __FILE__, __LINE__, __METHOD__, 10 );
				$this->db->RollBackTrans();

				return false;
			}

			$this->db->CommitTrans();

			Debug::Text( ' Returning True.', __FILE__, __LINE__, __METHOD__, 10 );

			return true;
		}

		return false;
	}

	/**
	 * @param $array
	 * @param null $ph
	 * @return string
	 */
	protected function getListSQL( $array, &$ph = null ) {
		//Debug::Arr($ph, 'Place Holder BEFORE:', __FILE__, __LINE__, __METHOD__, 10);

		//Append $array values to end of $ph, return
		//one "?, " for each element in $array.

		$ph_arr = [];
		$array_count = count( $array );
		if ( is_array( $array ) && $array_count > 0 ) {
			foreach ( $array as $val ) {
				$ph_arr[] = '?';
				$ph[] = $val;
			}

			if ( empty( $ph_arr ) == false ) {
				$retval = implode( ',', $ph_arr );
			}
		} else if ( is_array( $array ) ) {
			//Return NULL, because this is an empty array.
			//This may have to return -1 instead of NULL
			//$ph[] = 'NULL';
			$ph[] = -1;
			$retval = '?';
		} else if ( $array == '' ) {
			//$ph[] = 'NULL';
			$ph[] = -1;
			$retval = '?';
		} else {
			$ph[] = $array;
			$retval = '?';
		}

		//Debug::Arr($ph, 'Place Holder AFTER:', __FILE__, __LINE__, __METHOD__, 10);

		//Just a single ID, return it.
		return $retval;
	}

	/**
	 * @param string $object_id UUID
	 * @param bool $recurse
	 * @return bool
	 */
	function delete( $object_id, $recurse = false ) {
		Debug::Text( ' Deleting Object: ' . $object_id, __FILE__, __LINE__, __METHOD__, 10 );

		if ( $object_id == '' ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		//Find out if this node has children
		$this->db->BeginTrans();

		//This was the source of a bug that was causing the below recurse delete query
		//to delete the root node of the tree. getAllChildren was returning FALSE and array_keys()
		//was turning that into array(0 => 0), so we were deleting node 0 and XXX in a single operation.
		$children_ids = $this->getAllChildren( $object_id, 'RECURSE' );
		if ( $children_ids !== false && is_array( $children_ids ) ) {
			$children_ids = array_keys( $children_ids );
		} else {
			$children_ids = [];
		}

		if ( count( $children_ids ) == 0 ) {
			Debug::Text( ' No Children: ', __FILE__, __LINE__, __METHOD__, 10 );

			$ph = [
					'tree_id'   => (int)$this->getTree(),
					'object_id' => (int)$object_id,
			];

			$query = 'DELETE FROM ' . $this->table . ' WHERE tree_id = ? AND object_id = ?';
			$this->db->Execute( $query, $ph );
		} else if ( strtolower( $recurse ) == 'recurse' ) {
			Debug::Arr( $children_ids, ' Recursing Delete - Current Object: ' . $object_id . ' Child IDs: ', __FILE__, __LINE__, __METHOD__, 10 );

			$ph = [
					'tree_id' => $this->getTree(),
			];

			//Add current object_id to children for delete.
			$children_ids[] = $object_id;

			$query = 'DELETE FROM ' . $this->table . ' WHERE tree_id = ? AND object_id in (' . $this->getListSQL( $children_ids, $ph ) . ')';
			$this->db->Execute( $query, $ph );
		} else {
			Debug::Text( ' Re-parenting children: ', __FILE__, __LINE__, __METHOD__, 10 );

			$parent_id = $this->getParentId( $object_id );

			$ph = [
					'tree_id'   => (int)$this->getTree(),
					'object_id' => (int)$object_id,
			];

			$query = 'DELETE FROM ' . $this->table . ' WHERE tree_id = ? AND object_id = ?';
			$this->db->Execute( $query, $ph );

			$ph = [
					'parent_id' => (int)$parent_id,
					'tree_id'   => (int)$this->getTree(),
					'object_id' => (int)$object_id,
			];

			$query = '	UPDATE ' . $this->table . '
						SET parent_id = ?
						WHERE tree_id = ?
							AND parent_id = ?';
			$this->db->Execute( $query, $ph );
		}

		$this->db->CommitTrans();

		return true;
	}

	/**
	 * @param string $object_id UUID
	 * @param string $parent_id UUID
	 * @return bool
	 */
	function move( $object_id, $parent_id ) {
		Debug::Text( ' Object ID: ' . $object_id . ' Parent ID: ' . $parent_id, __FILE__, __LINE__, __METHOD__, 10 );

		if ( $object_id === '' ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		if ( $parent_id === '' ) {
			Debug::Text( ' bReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		//Make sure we don't reparent to self.
		$children_ids = array_keys( (array)$this->getAllChildren( $object_id, 'RECURSE' ) );

		if ( $parent_id != TTUUID::getZeroID() && is_array( $children_ids ) && in_array( $parent_id, $children_ids ) == true ) {
			Debug::Text( ' Objects cant be re-parented to their own children...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		$this->db->BeginTrans();

		$ph = [
				'parent_id' => (int)$parent_id,
				'tree_id'   => (int)$this->getTree(),
				'object_id' => (int)$object_id,
		];

		$query = '	UPDATE ' . $this->table . '
					SET parent_id = ?
					WHERE tree_id = ?
						AND object_id = ?';
		$this->db->Execute( $query, $ph );

		//FIXME: rebuild tree starting from object_id and parent_id only perhaps?
		//Might cut down on some work.
		$this->rebuildTree();

		$this->db->CommitTrans();

		return true;
	}

	/**
	 * @param string $object_id     UUID
	 * @param string $new_object_id UUID
	 * @return bool
	 */
	function edit( $object_id, $new_object_id ) {
		Debug::Text( ' Object ID: ' . $object_id . ' New Object ID: ' . $new_object_id, __FILE__, __LINE__, __METHOD__, 10 );

		if ( $object_id == '' ) {
			Debug::Text( ' aReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		if ( $new_object_id == '' ) {
			Debug::Text( ' bReturning False...', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}

		if ( $object_id == $new_object_id ) {
			Debug::Text( ' Object is the same ', __FILE__, __LINE__, __METHOD__, 10 );

			return true;
		}

		//Make sure new_object_id isn't already in the tree.
		if ( $this->getNode( $new_object_id ) === false ) {
			Debug::Text( ' Editing object ', __FILE__, __LINE__, __METHOD__, 10 );

			$this->db->BeginTrans();

			$ph = [
					'new_object_id' => (int)$new_object_id,
					'tree_id'       => (int)$this->getTree(),
					'object_id'     => (int)$object_id,
			];

			//Update parent IDs
			$query = '	UPDATE ' . $this->table . '
						SET parent_id = ?
						WHERE tree_id = ?
							AND parent_id = ?';
			$this->db->Execute( $query, $ph );

			//Update object ID
			$query = '	UPDATE ' . $this->table . '
						SET object_id = ?
						WHERE tree_id = ?
							AND object_id = ?';
			$this->db->Execute( $query, $ph );

			$this->db->CommitTrans();

			return true;
		} else {
			Debug::Text( ' New Object ID is already in the tree', __FILE__, __LINE__, __METHOD__, 10 );

			return false;
		}
	}

	/**
	 * Flex requires that all index keys start at 0, even in the children section,
	 * So we need to handle that as well so Flex doesn't need any post processing.
	 * @param $nodes
	 * @param bool $include_root
	 * @return array
	 */
	static function FormatFlexArray( $nodes, $include_root = true ) {
		Debug::Text( ' Formatting Flex Array...', __FILE__, __LINE__, __METHOD__, 10 );
		$nested = [];
		$depths = [];

		if ( is_array( $nodes ) ) {
			foreach ( $nodes as $node ) {
				if ( $node['level'] == 1 ) {

					//Using sequential keys
					$nested[] = $node; //Each new branch of the tree the key should start at 0 and be a sequence without holes.
					end( $nested );
					$depths[( $node['level'] + 1 )] = key( $nested );
					/*
					//Using non-sequential keys:
					$nested[$key] = $node;
					$depths[$node['level'] + 1] = $key;
					*/
				} else {
					$parent =& $nested;
					for ( $i = 2; $i <= $node['level']; $i++ ) {
						//In cases where parent nodes were deleted without reparenting, prevent PHP warning.
						if ( !isset( $depths[$i] ) ) {
							$depths[$i] = 0;
						}

						if ( $i == 2 ) {
							$parent =& $parent[$depths[$i]];
						} else {
							$parent =& $parent['children'][$depths[$i]];
						}
					}

					//Using sequential keys.
					$parent['children'][] = $node; //Each new branch of the tree the key should start at 0 and be a sequence without holes.
					end( $parent['children'] );
					$depths[( $node['level'] + 1 )] = key( $parent['children'] );
					/*
					//Using non-sequential keys:
					$parent['children'][$key] = $node;
					$depths[$node['level'] + 1] = $key;
					*/
				}
			}
		}

		if ( $include_root == true ) {
			return [
					0 => [
							'id'       => 0,
							'name'     => TTi18n::getText( 'Root' ),
							'level'    => 0,
							'children' => $nested,
					],
			];
		} else {
			return $nested;
		}
	}

	/**
	 * @param $nodes
	 * @param string $type
	 * @param bool $include_root
	 * @return array|bool
	 */
	static function FormatArray( $nodes, $type = 'HTML', $include_root = false ) {
		$type = strtolower( $type );

		if ( $include_root === true ) {
			if ( !is_array( $nodes ) ) {
				$nodes = [];
			}

			$root_node = [
					'id'    => 0,
					'name'  => 'Root',
					'level' => 0,
			];

			array_unshift( $nodes, $root_node );
		}

		if ( $nodes === false ) {
			return false;
		}

		$retarr = [];
		foreach ( $nodes as $node ) {
			switch ( $type ) {
				case 'no_tree_text':
					$spacing = str_repeat( '|  &nbsp;', ( $node['level'] * 1 ) );
					$text = $node['name'];
					break;
				case 'text':
					$spacing = str_repeat( '|  &nbsp;', ( $node['level'] * 1 ) );
					$text = $spacing . $node['name'];
					break;
				case 'plain_text':
					$spacing = str_repeat( '|  ', ( $node['level'] * 1 ) );
					$text = $spacing . $node['name'];
					break;
				case 'html':
					$width = ( ( $node['level'] - 1 ) * 20 );
					$spacing = '<img src="' . Environment::getBaseURL() . 'images/s.gif" width="' . $width . '">';
					$text = $spacing . ' ' . $node['name'];
					break;
				case 'array':
					break;
			}

			$node['spacing'] = $spacing;
			$node['text'] = $text;

			$retarr[] = $node;

			unset( $node );
		}

		return $retarr;
	}
}

?>