Source for file AkActsAsNestedSet.php

Documentation is available at AkActsAsNestedSet.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. // +----------------------------------------------------------------------+
  5. // | Akelos Framework - http://www.akelos.org                             |
  6. // +----------------------------------------------------------------------+
  7. // | Copyright (c) 2002-2006, Akelos Media, S.L.  & Bermi Ferrer Martinez |
  8. // | Released under the GNU Lesser General Public License, see LICENSE.txt|
  9. // +----------------------------------------------------------------------+
  10.  
  11. /**
  12. * @package ActiveRecord
  13. * @subpackage Behaviours
  14.  * @author Bermi Ferrer <bermi a.t akelos c.om>
  15.  * @author Jean-Christophe Michel, Symétrie
  16.  * @copyright Copyright (c) 2002-2006, Akelos Media, S.L. http://www.akelos.org
  17.  * @license GNU Lesser General Public License <http://www.gnu.org/copyleft/lesser.html>
  18.  */
  19.  
  20. require_once(AK_LIB_DIR.DS.'AkActiveRecord'.DS.'AkObserver.php');
  21.  
  22. class AkActsAsNestedSet extends AkObserver
  23. {
  24.  
  25.     /**
  26.     * This acts provides Nested Set functionality.  Nested Set is similiar to Tree, but with
  27.     * the added feature that you can select the children and all of it's descendants with
  28.     * a single query.  A good use case for this is a threaded post system, where you want
  29.     * to display every reply to a comment without multiple selects.
  30.     *
  31.     * A google search for "Nested Set" should point you in the direction to explain the
  32.     * data base theory.  I figured a bunch of this from
  33.     * http://threebit.net/tutorials/nestedset/tutorial1.html
  34.     *
  35.     * Instead of picturing a leaf node structure with child pointing back to their parent,
  36.     * the best way to imagine how this works is to think of the parent entity surrounding all
  37.     * of it's children, and it's parent surrounding it, etc.  Assuming that they are lined up
  38.     * horizontally, we store the left and right boundaries in the database.
  39.     *
  40.     * Imagine:
  41.     *   root
  42.     *     |_ Child 1
  43.     *       |_ Child 1.1
  44.     *       |_ Child 1.2
  45.     *     |_ Child 2
  46.     *       |_ Child 2.1
  47.     *       |_ Child 2.2
  48.     *
  49.     * If my circles in circles description didn't make sense, check out this sweet
  50.     * ASCII art:
  51.     *
  52.     *     ___________________________________________________________________
  53.     *    |  Root                                                             |
  54.     *    |    ____________________________    ____________________________   |
  55.     *    |   |  Child 1                  |   |  Child 2                  |   |
  56.     *    |   |   __________   _________  |   |   __________   _________  |   |
  57.     *    |   |  |  C 1.1  |  |  C 1.2 |  |   |  |  C 2.1  |  |  C 2.2 |  |   |
  58.     *    1   2  3_________4  5________6  7   8  9_________10 11_______12 13  14
  59.     *    |   |___________________________|   |___________________________|   |
  60.     *    |___________________________________________________________________| 
  61.     *
  62.     * The numbers represent the left and right boundaries.  The table them might
  63.     * look like this:
  64.     *    ID | PARENT | LEFT | RIGHT | DATA
  65.     *     1 |      0 |    1 |    14 | root
  66.     *     2 |      1 |    2 |     7 | Child 1
  67.     *     3 |      2 |    3 |     4 | Child 1.1
  68.     *     4 |      2 |    5 |     6 | Child 1.2
  69.     *     5 |      1 |    8 |    13 | Child 2
  70.     *     6 |      5 |    9 |    10 | Child 2.1
  71.     *     7 |      5 |   11 |    12 | Child 2.2
  72.     *
  73.     * So, to get all children of an entry, you
  74.     *     SELECT * WHERE CHILD.LEFT IS BETWEEN PARENT.LEFT AND PARENT.RIGHT
  75.     *
  76.     * To get the count, it's (LEFT - RIGHT + 1)/2, etc.
  77.     *
  78.     * To get the direct parent, it falls back to using the PARENT_ID field.   
  79.     *
  80.     * There are instance methods for all of these.
  81.     *
  82.     * The structure is good if you need to group things together; the downside is that
  83.     * keeping data integrity is a pain, and both adding and removing and entry
  84.     * require a full table write.        
  85.     *
  86.     * This sets up a beforeDestroy() trigger to prune the tree correctly if one of it's
  87.     * elements gets deleted.
  88.     *
  89.     */
  90.  
  91.     /**
  92.     * Configuration options are:
  93.     *
  94.     * * +parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
  95.     * * +left_column+ - column name for left boundary data, default "lft"
  96.     * * +right_column+ - column name for right boundary data, default "rgt"
  97.     * * +scope+ - restricts what is to be considered a list.
  98.     *   Example: <tt>actsAsList(array('scope' => array('todo_list_id = ? AND completed = 0',$todo_list_id)));</tt>
  99.     */
  100.  
  101.     var $_scope_condition;
  102.     var $_left_column_name = 'lft';
  103.     var $_right_column_name = 'rgt';
  104.     var $_parent_column_name = 'parent_id';
  105.  
  106.     var $_ActiveRecordInstance;
  107.  
  108.     function AkActsAsNestedSet(&$ActiveRecordInstance)
  109.     {
  110.         $this->_ActiveRecordInstance =& $ActiveRecordInstance;
  111.     }
  112.  
  113.     function init($options = array())
  114.     {
  115.         empty($options['parent_column']) ? null : ($this->_parent_column_name = $options['parent_column']);
  116.         empty($options['left_column']) ? null : ($this->_left_column_name = $options['left_column']);
  117.         empty($options['right_column']) ? null : ($this->_right_column_name = $options['right_column']);
  118.         empty($options['scope']) ? null : $this->setScopeCondition($options['scope']);
  119.         return $this->_ensureIsActiveRecordInstance($this->_ActiveRecordInstance);
  120.     }
  121.  
  122.  
  123.     function _ensureIsActiveRecordInstance(&$ActiveRecordInstance)
  124.     {
  125.         if(is_object($ActiveRecordInstance) && method_exists($ActiveRecordInstance,'actsLike')){
  126.             $this->_ActiveRecordInstance =& $ActiveRecordInstance;
  127.             if(!$this->_ActiveRecordInstance->hasColumn($this->_parent_column_name) || !$this->_ActiveRecordInstance->hasColumn($this->_left_column_name) || !$this->_ActiveRecordInstance->hasColumn($this->_right_column_name)){
  128.                 trigger_error(Ak::t(
  129.                 'The following columns are required in the table "%table" for the model "%model" to act as a Nested Set: "%columns".',array(
  130.                 '%columns'=>$this->getParentColumnName().', '.$this->getLeftColumnName().', '.$this->getRightColumnName(),'%table'=>$this->_ActiveRecordInstance->getTableName(),'%model'=>$this->_ActiveRecordInstance->getModelName())),E_USER_ERROR);
  131.                 unset($this->_ActiveRecordInstance->nested_set);
  132.                 return false;
  133.             }else{
  134.                 $this->observe(&$ActiveRecordInstance);
  135.             }
  136.         }else{
  137.             trigger_error(Ak::t('You are trying to set an object that is not an active record.'), E_USER_ERROR);
  138.             return false;
  139.         }
  140.         return true;
  141.     }
  142.  
  143.     function reloadActiveRecordInstance(&$nodeInstance)
  144.     {
  145.         AK_PHP5 ? null : $nodeInstance->nested_set->_ensureIsActiveRecordInstance($nodeInstance);
  146.     }
  147.  
  148.     function getType()
  149.     {
  150.         return 'nested set';
  151.     }
  152.  
  153.     function getScopeCondition()
  154.     {
  155.         if (!empty($this->variable_scope_condition)){
  156.             return $this->_ActiveRecordInstance->_getVariableSqlCondition($this->variable_scope_condition);
  157.  
  158.             // True condition in case we don't have a scope
  159.         }elseif(empty($this->scope_condition) && empty($this->scope)){
  160.             $this->scope_condition = ($this->_ActiveRecordInstance->_db->type() == 'postgre') ? 'true' : '1';
  161.         }elseif (!empty($this->scope)){
  162.             $this->setScopeCondition(join(' AND ',array_map(array(&$this,'getScopedColumn'),(array)$this->scope)));
  163.         }
  164.         return  $this->scope_condition;
  165.     }
  166.  
  167.  
  168.     function setScopeCondition($scope_condition)
  169.     {
  170.         if(!is_array($scope_condition) && strstr($scope_condition, '?')){
  171.             $this->variable_scope_condition = $scope_condition;
  172.         }else{
  173.             $this->scope_condition  = $scope_condition;
  174.         }
  175.     }
  176.  
  177.     function getScopedColumn($column)
  178.     {
  179.         if($this->_ActiveRecordInstance->hasColumn($column)){
  180.             $value = $this->_ActiveRecordInstance->get($column);
  181.             $condition = $this->_ActiveRecordInstance->getAttributeCondition($value);
  182.             $value = $this->_ActiveRecordInstance->castAttributeForDatabase($column, $value);
  183.             return $column.' '.str_replace('?', $value, $condition);
  184.         }else{
  185.             return $column;
  186.         }
  187.     }
  188.  
  189.     function getLeftColumnName()
  190.     {
  191.         return $this->_left_column_name;
  192.     }
  193.     function setLeftColumnName($left_column_name)
  194.     {
  195.         $this->_left_column_name = $left_column_name;
  196.     }
  197.  
  198.     function getRightColumnName()
  199.     {
  200.         return $this->_right_column_name;
  201.     }
  202.     function setRightColumnName($right_column_name)
  203.     {
  204.         $this->_right_column_name = $right_column_name;
  205.     }
  206.  
  207.  
  208.     function getParentColumnName()
  209.     {
  210.         return $this->_parent_column_name;
  211.     }
  212.     function setParentColumnName($parent_column_name)
  213.     {
  214.         $this->_parent_column_name = $parent_column_name;
  215.     }
  216.  
  217.     /**
  218.     * Returns true is this is a root node.
  219.     */
  220.     function isRoot()
  221.     {
  222.         $left_id = $this->_ActiveRecordInstance->get($this->getLeftColumnName());
  223.         return ($this->_ActiveRecordInstance->get($this->getParentColumnName()) == null) && ($left_id == 1) && ($this->_ActiveRecordInstance->get($this->getRightColumnName()) > $left_id);
  224.     }
  225.  
  226.     /**
  227.     * Returns true is this is a child node
  228.     */
  229.     function isChild()
  230.     {
  231.         $parent_id = $this->_ActiveRecordInstance->get($this->getParentColumnName());
  232.         $left_id = $this->_ActiveRecordInstance->get($this->getLeftColumnName());
  233.         return !($parent_id == 0 || is_null($parent_id)) && ($left_id > 1) && ($this->_ActiveRecordInstance->get($this->getRightColumnName()) > $left_id);
  234.     }
  235.  
  236.     /**
  237.     * Returns true if we have no idea what this is
  238.     */
  239.     function isUnknown()
  240.     {
  241.         return !$this->isRoot() && !$this->isChild();
  242.     }
  243.  
  244.     /**
  245.     * Added a child to this object in the tree.  If this object hasn't been initialized,
  246.     * it gets set up as a root node.  Otherwise, this method will update all of the
  247.     * other elements in the tree and shift them to the right. Keeping everything
  248.     * balanced. 
  249.     */
  250.     function addChild( &$child )
  251.     {
  252.         $self =& $this->_ActiveRecordInstance;
  253.         $self->reload();
  254.         $child->reload();
  255.         $left_column = $this->getLeftColumnName();
  256.         $right_column = $this->getRightColumnName();
  257.         $parent_column = $this->getParentColumnName();
  258.  
  259.         if ($child->nested_set->isRoot()){
  260.             trigger_error(Ak::t("Adding sub-tree isn't currently supported"),E_USER_ERROR);
  261.         }elseif ( (is_null($self->get($left_column))) || (is_null($self->get($right_column))) ){
  262.             // Looks like we're now the root node!  Woo
  263.             $self->set($left_column, 1);
  264.             $self->set($right_column, 4);
  265.  
  266.             $self->transactionStart();
  267.             // What do to do about validation?
  268.             if(!$self->save()){
  269.                 $self->transactionFail();
  270.                 $self->transactionComplete();
  271.                 return false;
  272.             }
  273.  
  274.             $child->set($parent_column, $self->getId());
  275.             $child->set($left_column, 2);
  276.             $child->set($right_column, 3);
  277.  
  278.             if(!$child->save()){
  279.                 $self->transactionFail();
  280.                 $self->transactionComplete();
  281.                 return false;
  282.             }
  283.             $self->transactionComplete();
  284.             return $child;
  285.         }else{
  286.             // OK, we need to add and shift everything else to the right
  287.             $child->set($parent_column, $self->getId());
  288.             $right_bound = $self->get($right_column);
  289.             $child->set($left_column, $right_bound);
  290.             $child->set($right_column, $right_bound +1);
  291.             $self->set($right_column, $self->get($right_column) + 2);
  292.  
  293.             $self->transactionStart();
  294.             $self->updateAll( "$left_column = ($left_column + 2)",  $this->getScopeCondition()." AND $left_column >= $right_bound" );
  295.             $self->updateAll( "$right_column = ($right_column + 2)",  $this->getScopeCondition()." AND $right_column >= $right_bound" );
  296.             $self->save();
  297.             $child->save();
  298.             $this->reloadActiveRecordInstance($child);
  299.             $self->transactionComplete();
  300.             return $child;
  301.         }
  302.     }
  303.  
  304.  
  305.     /**
  306.     * Returns the parent Object
  307.     */
  308.     function &getParent()
  309.     {
  310.         if(!$this->isChild()){
  311.             $result = false;
  312.         }else{
  313.             $result =& $this->_ActiveRecordInstance->find(
  314.             // str_replace(array_keys($options['conditions']), array_values($this->getSanitizedConditionsArray($options['conditions'])),$pattern);
  315.             'first', array('conditions' => " ".$this->getScopeCondition()." AND ".$this->_ActiveRecordInstance->getPrimaryKey()." = ".$this->_ActiveRecordInstance->{$this->getParentColumnName()})
  316.             );
  317.         }
  318.         return $result;
  319.     }
  320.  
  321.     /**
  322.     * Returns an array of parent Objects this is usefull to make breadcrum like stuctures
  323.     */
  324.     function &getParents()
  325.     {
  326.         $Ancestors =& $this->getAncestors();
  327.         return $Ancestors;
  328.     }
  329.  
  330.  
  331.     /**
  332.     * Prunes a branch off of the tree, shifting all of the elements on the right
  333.     * back to the left so the counts still work.
  334.     */
  335.     function beforeDestroy(&$object)
  336.     {
  337.         if(!empty($object->__avoid_nested_set_before_destroy_recursion)){
  338.             return true;
  339.         }
  340.         if((empty($object->{$this->getRightColumnName()}) || empty($object->{$this->getLeftColumnName()})) || $object->nested_set->isUnknown()){
  341.             return true;
  342.         }
  343.         $dif = $object->{$this->getRightColumnName()} - $object->{$this->getLeftColumnName()} + 1;
  344.  
  345.         $ObjectsToDelete = $object->nested_set->getAllChildren();
  346.  
  347.         $object->transactionStart();
  348.  
  349.         if(!empty($ObjectsToDelete)){
  350.             foreach (array_keys($ObjectsToDelete) as $k){
  351.                 $Child =& $ObjectsToDelete[$k];
  352.                 $Child->__avoid_nested_set_before_destroy_recursion = true;
  353.                 if($Child->beforeDestroy()){
  354.                     if($Child->notifyObservers('beforeDestroy') === false){
  355.                         $Child->transactionFail();
  356.                     }
  357.                 }else{
  358.                     $Child->transactionFail();
  359.                 }
  360.             }
  361.         }
  362.  
  363.         $object->deleteAll($this->getScopeCondition().
  364.         " AND ".$this->getLeftColumnName()." > ".$object->{$this->getLeftColumnName()}.
  365.         " AND ".$this->getRightColumnName()." < ".$object->{$this->getRightColumnName()});
  366.  
  367.         $object->updateAll($this->getLeftColumnName()." = (".$this->getLeftColumnName()." - $dif)",
  368.         $this->getScopeCondition()." AND ".$this->getLeftColumnName()." >= ".$object->{$this->getRightColumnName()} );
  369.  
  370.         $object->updateAll($this->getRightColumnName()." = (".$this->getRightColumnName()." - $dif )",
  371.         $this->getScopeCondition()." AND ".$this->getRightColumnName()." >= ".$object->{$this->getRightColumnName()});
  372.  
  373.  
  374.         if(!empty($ObjectsToDelete)){
  375.             foreach (array_keys($ObjectsToDelete) as $k){
  376.                 $Child =& $ObjectsToDelete[$k];
  377.                 $Child->__avoid_nested_set_before_destroy_recursion = true;
  378.                 if(!$Child->afterDestroy() || $Child->notifyObservers('afterDestroy') === false){
  379.                     $Child->transactionFail();
  380.                 }
  381.             }
  382.         }
  383.  
  384.         if($object->transactionHasFailed()){
  385.             $object->transactionComplete();
  386.             return false;
  387.         }
  388.         $object->transactionComplete();
  389.  
  390.         return true;
  391.     }
  392.  
  393.     /**
  394.      * on creation, set automatically lft and rgt to the end of the tree
  395.      */
  396.     function beforeCreate(&$object)
  397.     {
  398.         $object->nested_set->_setLeftAndRightToTheEndOfTheTree();
  399.         return true;
  400.     }
  401.  
  402.     function _setLeftAndRightToTheEndOfTheTree()
  403.     {
  404.         $left = $this->getLeftColumnName();
  405.         $right = $this->getRightColumnName();
  406.  
  407.         $maxright = $this->_ActiveRecordInstance->maximum($right, array('conditions'=>$this->getScopeCondition()));
  408.         $maxright = empty($maxright) ? 0 : $maxright;
  409.  
  410.         $this->_ActiveRecordInstance->set($left, $maxright+1);
  411.         $this->_ActiveRecordInstance->set($right, $maxright+2);
  412.     }
  413.  
  414.     /**
  415.      * Returns the single root
  416.      */
  417.     function getRoot()
  418.     {
  419.         return $this->_ActiveRecordInstance->find('first', array('conditions' => " ".$this->getScopeCondition()." AND ".$this->getParentColumnName()." IS NULL "));
  420.     }
  421.  
  422.     /**
  423.      * Returns roots when multiple roots (or virtual root, which is the same)
  424.      */
  425.     function getRoots()
  426.     {
  427.         return $this->_ActiveRecordInstance->find('all', array('conditions' => " ".$this->getScopeCondition()." AND ".$this->getParentColumnName()." IS NULL ",'order' => $this->getLeftColumnName()));
  428.     }
  429.  
  430.  
  431.     /**
  432.      * Returns an array of all parents 
  433.      */
  434.     function &getAncestors()
  435.     {
  436.         $Ancestors =& $this->_ActiveRecordInstance->find('all', array('conditions' => ' '.$this->getScopeCondition().' AND '.
  437.         $this->getLeftColumnName().' < '.$this->_ActiveRecordInstance->get($this->getLeftColumnName()).' AND '.
  438.         $this->getRightColumnName().' > '.$this->_ActiveRecordInstance->get($this->getRightColumnName())
  439.         ,'order' => $this->getLeftColumnName()));
  440.         return $Ancestors;
  441.     }
  442.  
  443.     /**
  444.      * Returns the array of all parents and self
  445.      */
  446.     function &getSelfAndAncestors()
  447.     {
  448.         if($result =& $this->getAncestors()){
  449.             array_push($result, $this->_ActiveRecordInstance);
  450.         }else{
  451.             $result = array(&$this->_ActiveRecordInstance);
  452.         }
  453.         return $result;
  454.     }
  455.  
  456.  
  457.     /**
  458.      * Returns the array of all children of the parent, except self
  459.      */
  460.     function getSiblings($search_for_self = false)
  461.     {
  462.         return $this->_ActiveRecordInstance->find('all', array('conditions' => ' (('.$this->getScopeCondition().' AND '.
  463.         $this->getParentColumnName().' = '.$this->_ActiveRecordInstance->get($this->getParentColumnName()).' AND '.
  464.         $this->_ActiveRecordInstance->getPrimaryKey().' <> '.$this->_ActiveRecordInstance->getId().
  465.         ($search_for_self&&!$this->_ActiveRecordInstance->isNewRecord()?') OR ('.$this->_ActiveRecordInstance->getPrimaryKey().' = '.$this->_ActiveRecordInstance->quotedId().'))':'))')
  466.         ,'order' => $this->getLeftColumnName()));
  467.     }
  468.  
  469.     /**
  470.      * Returns the array of all children of the parent, included self
  471.      */
  472.     function getSelfAndSiblings()
  473.     {
  474.         $parent_id = $this->_ActiveRecordInstance->get($this->getParentColumnName());
  475.         if(empty($parent_id) || !$result = $this->getSiblings(true)){
  476.             $result = array($this->_ActiveRecordInstance);
  477.         }
  478.         return $result;
  479.     }
  480.  
  481.  
  482.     /**
  483.      * Returns the level of this object in the tree 
  484.      * root level is 0
  485.      */
  486.     function getLevel()
  487.     {
  488.         $parent_id = $this->_ActiveRecordInstance->get($this->getParentColumnName());
  489.         if(empty($parent_id)){
  490.             return 0;
  491.         }
  492.         return $this->_ActiveRecordInstance->count(' '.$this->getScopeCondition().' AND '.
  493.         $this->getLeftColumnName().' < '.$this->_ActiveRecordInstance->get($this->getLeftColumnName()).' AND '.
  494.         $this->getRightColumnName().' > '.$this->_ActiveRecordInstance->get($this->getRightColumnName()));
  495.     }
  496.  
  497.  
  498.     /**
  499.     * Returns the number of all nested children of this object.
  500.     */
  501.     function countChildren()
  502.     {
  503.         $children_count = ($this->_ActiveRecordInstance->get($this->getRightColumnName()) - $this->_ActiveRecordInstance->get($this->getLeftColumnName()) - 1)/2;
  504.         return $children_count > 0 ? $children_count : 0;
  505.     }
  506.  
  507.  
  508.     /**
  509.      * Returns a set of only this entry's immediate children
  510.      */
  511.     function getChildren()
  512.     {
  513.         return $this->_ActiveRecordInstance->find('all', array('conditions' => ' '.$this->getScopeCondition().' AND '.
  514.         $this->getParentColumnName().' = '.$this->_ActiveRecordInstance->getId()
  515.         ,'order' => $this->getLeftColumnName()));
  516.     }
  517.  
  518.     /**
  519.      * Returns a set of all of its children and nested children
  520.      */
  521.     function getAllChildren()
  522.     {
  523.         $args = func_get_args();
  524.         $excluded_ids = array();
  525.         if(!empty($args)){
  526.             $exclude = count($args) > 1 ? $args : (is_array($args[0]) ? $args[0] : (empty($args[0]) ? false : array($args[0])));
  527.             if(!empty($exclude)){
  528.                 $parent_class_name = get_class($this->_ActiveRecordInstance);
  529.                 foreach (array_keys($exclude) as $k){
  530.                     $Item =& $exclude[$k];
  531.                     if(is_a($Item,$parent_class_name)){
  532.                         $ItemToExclude =& $Item;
  533.                     }else{
  534.                         $ItemToExclude =& $this->_ActiveRecordInstance->find($Item);
  535.                     }
  536.                     if($ItemSet = $ItemToExclude->nested_set->getFullSet()){
  537.                         foreach (array_keys($ItemSet) as $l){
  538.                             $excluded_ids[] = $ItemSet[$l]->getId();
  539.                         }
  540.                     }
  541.                 }
  542.                 $excluded_ids = array_unique(array_diff($excluded_ids,array('')));
  543.             }
  544.         }
  545.         return $this->_ActiveRecordInstance->find('all', array('conditions' => ' '.$this->getScopeCondition().' AND '.
  546.         (empty($excluded_ids) ? '' : ' id NOT IN ('.join(',',$excluded_ids).') AND ').
  547.         $this->getLeftColumnName().' > '.$this->_ActiveRecordInstance->get($this->getLeftColumnName()).' AND '.
  548.         $this->getRightColumnName().' < '.$this->_ActiveRecordInstance->get($this->getRightColumnName())
  549.         ,'order' => $this->getLeftColumnName()));
  550.     }
  551.  
  552.     /**
  553.      * Returns a set of itself and all of its nested children
  554.      */
  555.     function getFullSet($exclude = null)
  556.     {
  557.         if($this->_ActiveRecordInstance->isNewRecord() || $this->_ActiveRecordInstance->get($this->getRightColumnName()) - $this->_ActiveRecordInstance->get($this->getLeftColumnName()) == 1 ){
  558.             $result = array($this->_ActiveRecordInstance);
  559.         }else{
  560.         (array)$result = $this->getAllChildren($exclude);
  561.         array_unshift($result, $this->_ActiveRecordInstance);
  562.         }
  563.         return $result;
  564.     }
  565.  
  566.  
  567.     /**
  568.      * Move the node to the left of another node
  569.      */
  570.     function moveToLeftOf($node)
  571.     {
  572.         return $this->moveTo($node, 'left');
  573.     }
  574.  
  575.     /**
  576.      * Move the node to the left of another node
  577.      */
  578.     function moveToRightOf($node)
  579.     {
  580.         return $this->moveTo($node, 'right');
  581.     }
  582.  
  583.     /**
  584.      * Move the node to the child of another node
  585.      */
  586.     function moveToChildOf($node)
  587.     {
  588.         return $this->moveTo($node, 'child');
  589.     }
  590.  
  591.     function moveTo($target, $position)
  592.     {
  593.         if($this->_ActiveRecordInstance->isNewRecord()){
  594.             trigger_error(Ak::t('You cannot move a new node'), E_USER_ERROR);
  595.         }
  596.         $current_left = $this->_ActiveRecordInstance->get($this->getLeftColumnName());
  597.         $current_right = $this->_ActiveRecordInstance->get($this->getRightColumnName());
  598.         // $extent is the width of the tree self and children
  599.         $extent = $current_right - $current_left + 1;
  600.  
  601.         // load object if node is not an object
  602.         if (is_numeric($target)){
  603.             $target =& $this->_ActiveRecordInstance->find($target);
  604.         }
  605.         if(!$target || !is_a($target, get_class($this->_ActiveRecordInstance))){
  606.             trigger_error(Ak::t('Invalid target'), E_USER_NOTICE);
  607.             return false;
  608.         }
  609.  
  610.         $target_left = $target->get($this->getLeftColumnName());
  611.         $target_right = $target->get($this->getRightColumnName());
  612.  
  613.  
  614.         // detect impossible move
  615.         if ((($current_left <= $target_left) && ($target_left <= $current_right)) || (($current_left <= $target_right) && ($target_right <= $current_right))){
  616.             trigger_error(Ak::t('Impossible move, target node cannot be inside moved tree.'), E_USER_ERROR);
  617.         }
  618.  
  619.         // compute new left/right for self
  620.         if ($position == 'child'){
  621.             if ($target_left < $current_left){
  622.                 $new_left  = $target_left + 1;
  623.                 $new_right = $target_left + $extent;
  624.             }else{
  625.                 $new_left  = $target_left - $extent + 1;
  626.                 $new_right = $target_left;
  627.             }
  628.         }elseif($position == 'left'){
  629.             if ($target_left < $current_left){
  630.                 $new_left  = $target_left;
  631.                 $new_right = $target_left + $extent - 1;
  632.             }else{
  633.                 $new_left  = $target_left - $extent;
  634.                 $new_right = $target_left - 1;
  635.             }
  636.         }elseif($position == 'right'){
  637.             if ($target_right < $current_right){
  638.                 $new_left  = $target_right + 1;
  639.                 $new_right = $target_right + $extent;
  640.             }else{
  641.                 $new_left  = $target_right - $extent + 1;
  642.                 $new_right = $target_right;
  643.             }
  644.         }else{
  645.             trigger_error(Ak::t("Position should be either left or right ('%position' received).",array('%position'=>$position)), E_USER_ERROR);
  646.         }
  647.  
  648.         // boundaries of update action
  649.         $left_boundary = min($current_left, $new_left);
  650.         $right_boundary = max($current_right, $new_right);
  651.  
  652.         // Shift value to move self to new $position
  653.         $shift = $new_left - $current_left;
  654.  
  655.         // Shift value to move nodes inside boundaries but not under self_and_children
  656.         $updown = ($shift > 0) ? -$extent : $extent;
  657.  
  658.         // change null to NULL for new parent
  659.         if($position == 'child'){
  660.             $new_parent = $target->getId();
  661.         }else{
  662.             $target_parent = $target->get($this->getParentColumnName());
  663.             $new_parent = empty($target_parent) ? 'NULL' : $target_parent;
  664.         }
  665.  
  666.         $this->_ActiveRecordInstance->updateAll(
  667.  
  668.         $this->getLeftColumnName().' = CASE '.
  669.         'WHEN '.$this->getLeftColumnName().' BETWEEN '.$current_left.' AND '.$current_right.' '.
  670.         'THEN '.$this->getLeftColumnName().' + '.$shift.' '.
  671.         'WHEN '.$this->getLeftColumnName().' BETWEEN '.$left_boundary.' AND '.$right_boundary.' '.
  672.         'THEN '.$this->getLeftColumnName().' + '.$updown.' '.
  673.         'ELSE '.$this->getLeftColumnName().' END, '.
  674.  
  675.         $this->getRightColumnName().' = CASE '.
  676.         'WHEN '.$this->getRightColumnName().' BETWEEN '.$current_left.' AND '.$current_right.' '.
  677.         'THEN '.$this->getRightColumnName().' + '.$shift.' '.
  678.         'WHEN '.$this->getRightColumnName().' BETWEEN '.$left_boundary.' AND '.$right_boundary.' '.
  679.         'THEN '.$this->getRightColumnName().' + '.$updown.' '.
  680.         'ELSE '.$this->getRightColumnName().' END, '.
  681.  
  682.         $this->getParentColumnName().' = CASE '.
  683.         'WHEN '.$this->_ActiveRecordInstance->getPrimaryKey().' = '.$this->_ActiveRecordInstance->getId().' '.
  684.         'THEN '.$new_parent.' '.
  685.         'ELSE '.$this->getParentColumnName().' END',
  686.  
  687.         $this->getScopeCondition() );
  688.         $this->_ActiveRecordInstance->reload();
  689.  
  690.         return true;
  691.     }
  692.  
  693. }
  694.  
  695.  
  696. ?>
Documentation generated on Tue, 17 Jun 2008 14:24:34 +0200 by phpDocumentor 1.3.2