Zend FR

Moi j'ai plusieurs modules qui sont tous connecté au même models...je crois pas que c'est l'idéal de divisé les modèles dans les modules car il y a de forte chance que 2 modules doivent utilisé la même table...etc.

Pour répondre à ta question, tu dois faire comme ceci:

Regarde la fonction toArray(), elle transfome ton object de table en tableau

Doctrine_Core::getTable('Admin_Models_Utilisateurs')->find(1)->toArray();

Je commence à comprendre un peu le fonctionnement interne de doctrine.

Lors de la génération on a un Models_Matable et un Models_Base_Matable

Le Models_Matable permet de définir de nouvelles fonctions  à Models_Base_Matable. Jusque là je pense avoir bon.

Par contre par défaut il n'y a pas de fonctions genre fetchAll() fonctionnant comme Zend. J'ai eu envie de la définir dans mon Models_Matable mais je trouve que ça ne le fait pas trop côté respect du rôle de la classe.

En effet, cette classe définit un objet permettant d'interagir avec un enregistrement de la table en question. Or un fetchAll() retourne une collection de cet objet.

Faut il créer une autre classe avec dedans une fonction pour chaque requête? comme par exemple un Models_Table_Matable??

Je me pose ces questions car la documentation et les différentes aides trouvées sont peu parlante sur le sujet.

EDIT:

J'édite pour éviter les multi posts.

J'ai modifié l'application pour avoir une classe extends Doctrine_Table afin de définir mes requêtes dedans. Je pense, comme ceci être dans la bonne voie.

Voici par exemple ma classe Table:

/**
 * Models_UtilisateursTable
 * 
 * This class has been auto-generated by the Doctrine ORM Framework
 */
class Admin_Models_UtilisateursTable extends Doctrine_Table
{
    /**
     * Returns an instance of this class.
     *
     * @return object Models_UtilisateursTable
     */
    public static function getInstance()
    {
        return Doctrine_Core::getTable('Admin_Models_Utilisateurs');
    }
    
    /**
     * 
     * Fonction permettant d'effectuer les requêtes SQL de base.
     * 
     * @param $where
     * @param $order
     * @param $limit
     * @param $offset
     * @return unknown_type
     */
    public function fetchAll($where=null, $order=null, $limit=null, $offset=null)
    {
        $select = Doctrine_Query::create()
            ->select('*')
            ->from('Admin_Models_Utilisateurs');
            
        if(isset($where)){ $select->where($where); }
        if(isset($order)){ $select->orderBy($order); }
        if(isset($limit)){ $select->limit($limit); }
        if(isset($offset)){ $select->offset($offset); }
        
        return $select->execute();
    }
}

et voici comment je récupère ma collection dans mon contrôleur (ici je test juste)

$table = Doctrine_Core::getTable('Admin_Models_Utilisateurs');
        
$liste = $table->fetchAll();
        
foreach($liste as $unuser)
{
    print_r($unuser->login);
    print_r($unuser->passwd);
}

Je pense avoir trouvé comment fonctionne Doctrine et son intégration au sein de ZF semble en fait assez simple.

En plus, ici la migration de Zend_Db à Doctrine me permet de changer juste 2-3 lignes par contrôleur, les vues n'ont aucune modifications.

J'en conclue que l'utilisation de doctrine est, sur bien des points comparable à un Zend_Db_Table_Abstract. Après, en arrière plan nous nous retrouvons avec une vraie couche ORM.

Si je dis des bêtises, corrigez moi tout de suite.

Dernière modification par throrin19 (18-04-2010 16:30:16)