Zend FR

$menuDroite = new Menu();
$menuDroite->add(....);
$menuDroite->add(....);
$menuDroite->add(....);

$this->menuPool->add($menuDroite);

echo $this->menuPool->toString();

<ul>
   <li> <a href=.....   <li/>
   <li> <a href=.....   <li/>
<ul/>

$menu->Add( $href, $target, $options );

class Menu {

    private $_items = array();
    private $_userRole;
    
    /**
     * @param string $role
     */
    public function setUserRole($role)
    {
        $this->_userRole = $role;
    }
    
    /**
     * @param Menu_Item $item
     */
    public function addItem(Menu_Item $item)
    {
         $this->_items[] = $item;
    }
    
    /**
     * Retourne un tableau d'items de menu
     * 
     * @return array
     */
    public function getItems()
    {
       return $this->_items;
    }
    
    /**
     * @return array
     */
    public function getAllowedItems()
    {
        $allowedItems = array();
        
        foreach($this->_items as $item) {
            if ($item->isAllowed($this->_userRole)) {
                $allowedItems[] = $item;
            }
        }
        
        return $allowedItems;
    }
    
    /**
     * @return Menu_Item
     */
    public function getActiveItem()
    {
        foreach ($this->_items as $item)
        {
            if ($item->isActive()) {
                return $item;
            }
        }
        return null;
    }
}

<?php
class Menu_Item
{
    private $_href = '';
    private $_title = '';
    private $_description = '';
    private $_active = false;
    private $_roles = array();
    private $_submenu = null;
    
    /**
     * @param string $href
     */
    public function setHref($href)
    {
        $href = '/' . ltrim($href, '/');
        $this->_href = $href;
    }

    /**
     * @return string
     */
    public function getHref()
    {
        return BASE_URI . $this->_href;
    }
    
    /**
     * @param string $title
     */
    public function setTitle($title)
    {
        $this->_title = $title;
    }
    
    /**
     * @return string
     */
    public function getTitle()
    {
        return $this->_title;
    }
    
    /**
     * @param string $description
     */
    public function setDescription($description)
    {
         $this->_description = $description;
    }
    
    /**
     * @return string
     */
    public function getDescription()
    {
        return $this->_description;
    }
    
    /**
     * @param bool
     */
    public function setActive($active)
    {
        $this->_active = (bool) $active;
    }

    /**
     * @return bool
     */
    public function isActive()
    {
        return $this->_active;
    }
    
    /**
     * @param array|string $roles
     * @param string $seperator 
     */
    public function setRoles($roles, $seperator = '|')
    {
        if (is_array($roles)) {
            $this->_roles = $roles;
        }
        else {
            $this->_roles = explode($seperator, $roles);
        }
    }
    
    /**
     * @return array
     */
    public function getRoles()
    {
        return $this->_roles;
    }
    
    /**
     * @return bool
     */
    public function isAllowed($role)
    {
        if (in_array($role, $this->_roles)) {
            return true;
        }
        else {
            return false;
        }
    }
    
    /**
     * @param $submenu Menu
     */
    public function addSubMenu(Menu $submenu)
    {
        $this->_submenu = $submenu;
    }
    
    /**
     * @return Menu
     */
    public function getSubMenu()
    {
        return $this->_submenu;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<menus>
    <item href="/" roles="guest">
        <title>Retour à l'accueil</title>
        <description>Accueil</description>
    </item>
    <item href="/become-user" roles="guest">
        <title></title>
        <description>Devenez un utilisateur</description>
    </item>
    <item href="/become-client" roles="guest">
        <title></title>
        <description>Devenez client</description>
    </item>
    <item href="/who-are-we" roles="guest">
        <title>Découvrez qui nous sommes</title>
        <description>Qui sommes-nous ?</description>
    </item>
    <item href="/faq" roles="guest">
        <title>Foire aux questions</title>
        <description>FAQ</description>
        <submenu>
            <item href="/test" roles="guest">
                <title>TEST !</title>
                <description>Test</description>
            </item>
        </submenu>
    </item>
</menus>

<?php if (isset($this->items) && count($this->items) > 0) : ?>
    <ul id="primary-menu">
    <?php foreach($this->items as $item) : ?>
        <?php if ($item->isActive() === true) : ?>
        <li class="active"><a href="<?php echo $item->getHref(); ?>" title="<?php echo $item->getTitle() ?>"><?php echo $item->getDescription(); ?></a></li>
        <?php else : ?>
        <li><a href="<?php echo $item->getHref(); ?>" title="<?php echo $item->getTitle() ?>"><?php echo $item->getDescription(); ?></a></li>
        <?php endif; ?>
    <?php endforeach; ?>
    </ul>
<?php endif; ?>

<?php if (isset($this->items) && count($this->items) > 0) : ?>
    <ul id="secondary-menu">
    <?php foreach($this->items as $item) : ?>
        <?php if ($item->isActive() === true) : ?>
        <li class="active"><a href="<?php echo $item->getHref(); ?>" title="<?php echo $item->getTitle() ?>"><?php echo $item->getDescription(); ?></a></li>
        <?php else : ?>
        <li><a href="<?php echo $item->getHref(); ?>" title="<?php echo $item->getTitle() ?>"><?php echo $item->getDescription(); ?></a></li>
        <?php endif; ?>
    <?php endforeach; ?>
    </ul>
<?php endif; ?>

<?php
/**
 * Controller permettant l'affichage des menus suivant le role de l'utilisateur
 *
 */
class NavigationController extends Zend_Controller_Action
{
    /**
     * @var Menu
     */
    private $_menu = null;
    
    private $_userRole = null;
    
    public function init()
    {
        define("BASE_URI", "http://www.monsite.com");
        $auth = Zend_Auth::getInstance();
        
        if ($auth->hasIdentity()) {
            $this->_userRole = $auth->getIdentity()->role;
        }
        else {
            $this->_userRole = 'guest';
        }
        
        $primaryMenu = new Menu();
        $primaryMenu->setUserRole($this->_userRole);
        
        $xml = simplexml_load_file('menusdata.xml');

        foreach ($xml->children() as $noeud) {
            $primaryItem = new Menu_Item();
            $primaryItem->setTitle($noeud->title);
            $primaryItem->setDescription($noeud->description);
            $primaryItem->setHref($noeud['href']);
            $primaryItem->setRoles($noeud['roles']);
            
            if ($noeud['href'] == $_SERVER['REQUEST_URI']) {
                $primaryItem->setActive(true);
            }
            
            $primaryMenu->addItem($primaryItem);
            
            if (isset($noeud->submenu)) {
                $secondaryMenu = new Menu();
                $secondaryMenu->setUserRole($this->_userRole);
                
                foreach ($noeud->submenu->children() as $subitem) {
                    $secondaryItem = new Menu_Item();
                    $secondaryItem->setTitle($subitem->title);
                    $secondaryItem->setDescription($subitem->description);
                    $secondaryItem->setHref($subitem['href']);
                    $secondaryItem->setRoles($subitem['roles']);
                    
                    if ($subitem['href'] == $_SERVER['REQUEST_URI']) {
                        $secondaryItem->setActive(true);
                        $primaryItem->setActive(true);
                    }
                    
                    $secondaryMenu->addItem($secondaryItem);
                }
                $primaryItem->addSubMenu($secondaryMenu);
            }
        }
        
        $this->_menu = $primaryMenu;
    }
    
    /**
     * Construit le menu primaire suivant les rôles définit 
     * dans le fichier XML des menus
     * 
     * @return void
     */
    public function primarymenuAction ()
    {
        $this->view->items = $this->_menu->getAllowedItems();
    }
    
    public function secondarymenuAction ()
    {
        $submenu = $this->_menu->getActiveItem()->getSubMenu();
        
        if ($submenu !== null) {
            $this->view->items = $submenu->getAllowedItems();
        }
    }
    
    public function breadcrumbAction() 
    {
    }
}

<?php echo $this->doctype('XHTML1_TRANSITIONAL'); ?>
<html xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <?php echo $this->headTitle() ?>
        <base href="<?php echo BASE_URI ?>" />
        <?php echo $this->headScript() ?>
        <?php echo $this->headMeta() ?>
        <?php echo $this->headLink()->appendStylesheet('/styles/global.css'); ?>
        <?php echo $this->headStyle() ?>
    </head>
    <body>
        <div id="main-content">
            <?php echo $this->action('primarymenu', 'navigation'); ?>
            <?php echo $this->action('secondarymenu', 'navigation'); ?>
            
            <?php echo $this->layout()->header ?>
            <?php echo $this->layout()->content?>
            <?php echo $this->layout()->footer ?>
        </div>
    </body>
</html>

/**********************
 * Menu
 **********************/
ul#primary-menu, ul#secondary-menu {
    text-transform: uppercase;
    background-color: #b0d5f7;
    color: white;
    line-height: 2em;
    clear: both;
    margin-bottom: 1em;
}

ul#secondary-menu {
    background-color: #DFF0FF;
}

ul#primary-menu li, ul#secondary-menu li {
    display: inline;
    padding: 0 1em;
    line-height: 2em;
}

ul#primary-menu a, ul#secondary-menu a {
    color: #113356;
    font-weight: bold;
}

ul#primary-menu a:hover, ul#secondary-menu a:hover {
    color: white;
}

ul#primary-menu .active, ul#secondary-menu .active {
    font-weight: bold;
    background-color: #113356;
    padding: 0 2em;
}

ul#secondary-menu .active {
    background-color: #294C6F;
}

ul#primary-menu .active a, ul#secondary-menu .active a {
    color: white;
    text-decoration: none;
}

<?php
Zend_Loader::loadClass('Fast_Db_Table');

Class Fast_Db_Hierarchical extends Fast_Db_Table {
   
   /**
   * left field neme in table
   *
   * @var string
   */
   protected $_left = NULL;

   /**
   * right field neme in table
   *
   * @var string
   */
   protected $_right = NULL;

   /**
   * level field neme in table
   *
   * @var string
   */
   protected $_level = NULL;

   /**
   * virtual field name used has id of parent
   *
   * @var string
   */
   protected $_parent = NULL;

   public function __construct($config = array())
   {
      parent::__construct($config);
      if (null == $this->_left)   throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_LEFT_KEY);
      if (null == $this->_right)  throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_RIGHT_KEY);
      if (null == $this->_level)  throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_LEVEL_KEY);
      if (null == $this->_parent) throw new Fast_Exception_Db(Fast_Exception_Db::UNDEFINED_PARENT);
      $this->_cols[] = $this->_parent; 
   }

   public function getById($id) {
      $rows = $this->find($id);
      if ($rows) {
         return $rows->current();
      }
      return false;
   }
   
   public function deleteById($id) {
      if ($id == 1) return false; // on ne peut supprimer la racine

      $this->_db->beginTransaction();
      $parent = $this->_db->select();
      $parent->from($this->_name, array('delete_left' => $this->_left, 'delete_right' => $this->_right))
             ->where($this->_primary[1].' = :_deleteId');
      $statement = $this->_db->prepare($parent);
      $statement->execute(array('_deleteId' => $id));
      list($deleteLeft, $deleteRight) = array_values($statement->fetch());
      $res = false;
      if ($deleteLeft) {
         $row = $this->getById($id);
         $res = $row->delete();

         if ($res) {
            $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_left.' = '.$this->_left.' - 1 WHERE '.$this->_left.' >= '.$deleteLeft.' AND '.$this->_right.' < '.$deleteRight.';');
            $statement->execute();
         }
         
         if ($res) {
            $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_left.' = '.$this->_left.' - 2 WHERE '.$this->_left.' >= '.$deleteLeft.' AND '.$this->_right.' > '.$deleteRight.';');
            $statement->execute();
         }
         
         if ($res) {
            $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_right.' = '.$this->_right.' - 1 WHERE '.$this->_right.' >= '.$deleteLeft.' AND '.$this->_right.' < '.$deleteRight.';');
            $statement->execute();
         }
         
         if ($res) {
            $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_right.' = '.$this->_right.' - 2 WHERE '.$this->_right.' >= '.$deleteLeft.' AND '.$this->_right.' > '.$deleteRight.';');
            $statement->execute();
         }

         if ($res) {
            $this->_db->commit();
         } else {
            $this->_db->rollback();
         }
      }
      return $res;
   }

   public function UpdateById($data) {
      // on ne peut mettre à jour les donnée hiérarchique
      // ie on ne peut déplacer un noeud dans l'arbre.
      unset($data[$this->_parent]); // ne fait pas partie de la table
      unset($data[$this->_left]);   //ne peut être changé
      unset($data[$this->_right]);  //ne peut être changé
      unset($data[$this->_level]);  //ne peut être changé
      $res =  parent::UpdateById($data);
      return $res;
   }

    public function insert(array $data) {
      # select left and level of parent
      $parentId = $data[$this->_parent];
      
      $this->_db->beginTransaction();
      $parent = $this->_db->select();
      if (null != $this->_level) {
         $fields = array('parent_left' => $this->_left, 'parent_level' => $this->_level);
      } else {
         $fields = array('parent_left' => $this->_left,);
      }

      $parent->from($this->_name, $fields)
             ->where($this->_primary[1].' = :_parentId');
      $statement = $this->_db->prepare($parent);
      $statement->execute(array('_parentId' => $parentId));
      list($parentLeft, $parentLevel) = array_values($statement->fetch());

      $res = false;
      if ($parentLeft) {
         #update tree
         $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_left.' = '.$this->_left.' + 2 WHERE '.$this->_left.' > '.$parentLeft.';');
         $res = $statement->execute();
         if ($res) {
            $statement = $this->_db->prepare('UPDATE '.$this->_name.' SET '.$this->_right.' = '.$this->_right.' + 2 WHERE '.$this->_right.' > '.$parentLeft.';');
            $statement->execute();
         }
   
         #insert node
         if ($res) {
            unset($data[$this->_parent]);
            $data[$this->_left] = $parentLeft + 1;
            $data[$this->_right] = $parentLeft + 2;
            if (null != $this->_level)
               $data[$this->_level] = $parentLevel + 1;
            $res =  parent::insert($data);
           }           
         if ($res) {
            $this->_db->commit();
         } else {
            $this->_db->rollback();
         }
      }
      return $res;
    }

    /**
     * Support method for fetching rows.
     *
     * @param  string|array $where  OPTIONAL An SQL WHERE clause.
     * @param  string|array $order  OPTIONAL An SQL ORDER clause.
     * @param  int          $count  OPTIONAL An SQL LIMIT count.
     * @param  int          $offset OPTIONAL An SQL LIMIT offset.
     * @return array The row results, in FETCH_ASSOC mode.
     */
    protected function _fetch($where = null, $order = null, $count = null, $offset = null)
    {
        // selection tool
        $select = $this->_db->select();

        //no _parent col on master table
        $cols = $this->_cols;
        unset($cols[array_search($this->_parent,$cols)]);

        // the FROM clause
        $select->from($this->_name, $cols, $this->_schema);
        // add the parent col
        $select->join(array('parent' => $this->_name),
                      '(parent.'.$this->_left.' < workgroup.'.$this->_left.') AND 
                       (parent.'.$this->_right.' > workgroup.'.$this->_right.') AND 
                       (parent.'.$this->_level.' = workgroup.'.$this->_level.' -1)', 
                      array('parent_id' => 'parent.'.$this->_primary[1].''));

        // the WHERE clause
        $where = (array) $where;
        foreach ($where as $key => $val) {
            // is $key an int?
            if (is_int($key)) {
                // $val is the full condition
                $select->where($val);
            } else {
                // $key is the condition with placeholder,
                // and $val is quoted into the condition
                $select->where($key, $val);
            }
        }

        // the ORDER clause
        if (!is_array($order)) {
            $order = array($order);
        }
        foreach ($order as $val) {
            $select->order($val);
        }

        // the LIMIT clause
        $select->limit($count, $offset);
        // return the results
        $stmt = $this->_db->query($select);
        $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
        return $data;
    }

    public function update(array $data, $where)
    {
      unset($this->_cols[array_search($this->_parent,$this->_cols)]);
      unset($data[$this->_parent]);
      $res = parent::update($data, $where);
      $this->_cols[] = $this->_parent;
      return $res;
    }

   protected function _parent($row, $fiels) {
      $parent = $this->_parents($row, $fiels)
             ->order($this->_right)
             ->limit(1);
      return $parent;
   } 
   protected function _parents($row, $fiels) {
      $parent = $this->_db->select();
      $parent->from($this->_name, $fiels)
             ->where($this->_left.'  < '.$row->{$this->_left})
             ->where($this->_right.' > '.$row->{$this->_right});
      return $parent;
   } 
   protected function _childs($row, $fiels) {
      $childs = $this->_db->select();
      $childs->from($this->_name, $fiels)
             ->where($this->_left.'  > '.$row->{$this->_left})
             ->where($this->_right.' < '.$row->{$this->_right});
      return $childs;
   } 

    /**
     * This is the find Zend_Db_Table Abstract method
     * But the where closes are prefixed by the table name     
     *
     * Fetches rows by primary key.
     * The arguments specify the primary key values.
     * If the table has a multi-column primary key, you must
     * pass as many arguments as the count of column in the
     * primary key.
     *
     * To find multiple rows by primary key, the argument
     * should be an array.  If the table has a multi-column
     * primary key, all arguments must be arrays with the
     * same number of elements.
     *
     * The find() method always returns a Rowset object,
     * even if only one row was found.
     *
     * @param  mixed                         The value(s) of the primary key.
     * @return Zend_Db_Table_Rowset_Abstract Row(s) matching the criteria.
     * @throws Zend_Db_Table_Exception
     */
    public function find($key)
    {
        $args = func_get_args();
        $keyNames = array_values((array) $this->_primary);

        if (empty($args)) {
            require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception("No value(s) specified for the primary key");
        }

        if (count($args) != count($keyNames)) {
            require_once 'Zend/Db/Table/Exception.php';
            throw new Zend_Db_Table_Exception("Missing value(s) for the primary key");
        }

        $whereList = array();
        $numberTerms = 0;
        foreach ($args as $keyPosition => $keyValues) {
            // Coerce the values to an array.
            // Don't simply typecast to array, because the values
            // might be Zend_Db_Expr objects.
            if (!is_array($keyValues)) {
                $keyValues = array($keyValues);
            }
            if ($numberTerms == 0) {
                $numberTerms = count($keyValues);
            } else if (count($keyValues) != $numberTerms) {
                require_once 'Zend/Db/Table/Exception.php';
                throw new Zend_Db_Table_Exception("Missing value(s) for the primary key");
            }
            for ($i = 0; $i < count($keyValues); ++$i) {
                $whereList[$i][$keyPosition] = $keyValues[$i];
            }
        }
        $whereClause = null;
        if (count($whereList)) {
            $whereOrTerms = array();
            foreach ($whereList as $keyValueSets) {
                $whereAndTerms = array();
                foreach ($keyValueSets as $keyPosition => $keyValue) {
                    $whereAndTerms[] = $this->_db->quoteInto(
                        $this->_db->quoteIdentifier($this->_name).'.'.$this->_db->quoteIdentifier($keyNames[$keyPosition], true) . ' = ?',
                        $keyValue
                    );
                }
                $whereOrTerms[] = '(' . implode(' AND ', $whereAndTerms) . ')';
            }
            $whereClause = '(' . implode(' OR ', $whereOrTerms) . ')';
        }

        return $this->fetchAll($whereClause);
    }


}

<?php
Zend_Loader::loadClass('Fast_Db_Hierarchical');
require_once dirname(__FILE__).'/Row.php';

Class Adm_Model_Group_Table extends Fast_Db_Hierarchical {
   
   /**
   * The table name.
   *
   * @var array
   */
   protected $_name = 'workgroup';
   
   /**
   * Classname for row
   *
   * @var string
   */
   protected $_rowClass = 'Adm_Model_Group_Row';
      
   /**
   * Restriction for query
   *
   * @var string
   */
   protected $_restrict = array('workgroup.wkg_level >= 0');

   /**
   * left field neme in table
   *
   * @var string
   */
   protected $_left = 'wkg_left';

   /**
   * right field neme in table
   *
   * @var string
   */
   protected $_right = 'wkg_right';

   /**
   * level field neme in table
   *
   * @var string
   */
   protected $_level = 'wkg_level';

   /**
   * field neme used has id of parent
   *
   * @var string
   */
   protected $_parent = 'parent_id';

   public function __construct($config = array())
   {
      parent::__construct($config);
      $user = Zend_Auth::getInstance()->getIdentity();
      if ($user) {
         //L’utilisateur ne peut voir que les groupes fils de celui dans lequel in exerce sont rôle.
         $this->_restrict[] = $this->_name.'.wkg_left >= (SELECT wkg_left FROM workgroup WHERE wkg_id = '.$user->profile->wkg_id.')';
         $this->_restrict[] = $this->_name.'.wkg_right <= (SELECT wkg_right FROM workgroup WHERE wkg_id = '.$user->profile->wkg_id.')';
      } else {
         $this->_restrict = 'false'; //sans identité on ne peut rien voir dans la base
      }
   }

   public function getList($forParent=false, $withParent = false) {
      $select = $this->_db->select(); // @var $select Zend_Db_Select
      $select
      ->from($this->_name, array(
               'id'=>$this->_primary[1], 
               'ident'=>'wkg_code', 
               'name'=>'wkg_label',
               'level'=>$this->_level
            ))
      ->order($this->_left, 'wkg_label')
      ;
      $user = Zend_Auth::getInstance()->getIdentity();
      if ($forParent&&$user) {
         if ($withParent) {
            $curentWorkGroup = $this->getById($user->profile->wkg_id);
            $parent_id = $curentWorkGroup->parent_id;
         } else {
            $parent_id = $user->profile->wkg_id;
         }
         $select
         ->join('workgroup_type', 'workgroup_type.wgt_id = workgroup.wgt_id', array())
         ->where($this->_name.'.wkg_left >= (SELECT wkg_left FROM workgroup WHERE wkg_id = '.$parent_id.')')
         ->where($this->_name.'.wkg_right <= (SELECT wkg_right FROM workgroup WHERE wkg_id = '.$parent_id.')')
         ->where('wgt_right > wgt_left + 1');
         #Fast_Debug::show("$select",false);
         return $this->_getList($select, null, false);
      } else {
         return $this->_getList($select);
      }
   } 

   public function getGroupTypes($parent_id = NULL) {
      $user = Zend_Auth::getInstance()->getIdentity();
      if ($user) {
         //L’utilisateur ne peut voir que les groupes pour lesquels il peut gérer un rôle.
         $currentRoleId = $user->profile->rol_id;
         $select = $this->_db->select(); // @var $select Zend_Db_Select
         $select->distinct()
         ->from('workgroup_type', array(
                  'value'=>'wgt_id', 
                  'label'=>'wgt_label'
               ))
         ->join('workgroup_type_role', 'workgroup_type.wgt_id = workgroup_type_role.wgt_id', array())
         ->join('role', 'workgroup_type_role.rol_id = role.rol_id', array())
         ->where('wgt_valid = 1')
         ->where('rol_left >= (SELECT rol_left FROM role WHERE rol_id = :_currentRole)')
         ->where('rol_right <= (SELECT rol_right FROM role WHERE rol_id = :_currentRole)')
         ->order('wgt_label')
         ;
         if (NULL != $parent_id) {
            $select->where('wgt_left >= (SELECT wgt_left FROM workgroup_type WHERE wgt_id = (SELECT wgt_id FROM workgroup WHERE wkg_id = :_currentParent))')
            ->where('wgt_right <= (SELECT wgt_right FROM workgroup_type WHERE wgt_id = (SELECT wgt_id FROM workgroup WHERE wkg_id = :_currentParent))')
            ->where('wgt_level = (SELECT wgt_level + 1 FROM workgroup_type WHERE wgt_id = (SELECT wgt_id FROM workgroup WHERE wkg_id = :_currentParent))');
         }
         #Fast_Debug::show("$select",array('_currentRole' => $currentRoleId, '_currentParent' => $parent_id));
         //on n'utilise pas les contraintes définies sur la table workgroup
         //  d'où le false en dernier paramètres
         return $this->_getList($select, array('_currentRole' => $currentRoleId, '_currentParent' => $parent_id), false);
      } else {
         return array();
      }
   } 

   public function getAvailableGroupByRoleId($roleId, $selectedGroupId) {
      $user = Zend_Auth::getInstance()->getIdentity();
//Fast_Debug::show('$user', $user);

      if ($user) {
         //L’utilisateur ne peut voir que les groupes pour lesquels il peut gérer un rôle.
         $currentRoleId = $user->profile->rol_id;
         $select = $this->_db->select(); // @var $select Zend_Db_Select
         $select
         ->from('workgroup', array(
            'value'    => 'wkg_id',
            'label'  => 'wkg_label',
            'selected' => '(workgroup.wkg_id = :_selected)'
            ))
         ->join('workgroup_type_role', 'workgroup.wgt_id = workgroup_type_role.wgt_id', array())
         ->join('role', 'workgroup_type_role.rol_id = role.rol_id', array())
         ->where('workgroup_type_role.rol_id = :_id')
         ->where('rol_left >= (SELECT rol_left FROM role WHERE rol_id = :_currentRole)')
         ->where('rol_right <= (SELECT rol_right FROM role WHERE rol_id = :_currentRole)')
         ;
/*Fast_Debug::show("$select",array('_id' => $roleId,
                                               '_selected' => $selectedGroupId,
                                               '_currentRole' => $currentRoleId));*/

         return $this->_getList($select, array('_id' => $roleId, 
                                               '_selected' => $selectedGroupId, 
                                               '_currentRole' => $currentRoleId));
      } else {
         return array();
      }
   } 

}