Bonjour,

Je me demandais s'il était prévu, dans une prochaine évolution, la modification de l'API des DAOs, en vue d'une syntaxe plus "simple" et plus courante (utilisée généralement par les autres frameworks).

À savoir, par exemple, si on souhaite modifier un enregistrement issu d'une table foo :

$record = new Foo(id);
$record->myField = "toto";
$record->save();

Je trouve cette syntaxe beaucoup plus intuitive. On applique ici, directement sur l'objet record, les méthodes insert(), update(), delete() ou save();

Bien-sûr, la première ligne est à adapter, pour permettre l'emploi des sélecteurs propres à Jelix, ce qui deviendrait, par exemple :

$foo = DaoFactory::get(myJelixSelector);

ou, si vous comptiez utiliser les namespaces :

$foo = new my/name/space/Foo();

Pour retourner un ensemble d'enregistrement, on pourrait avoir :

$foo = new Foo();
$records = foo->findAll();

Ou, avec la nouvelle syntaxe qui sera proposée par PHP :

$records = new Foo()->findAll();

Merci pour votre réponse.

Bonsoir,

on peut deja faire des findAll / get :

$records = jDao::get('foo~bar')->findAll();

$dao = jDao::get('foo~bar');
$monrecord = jDao::get('foo~bar')->get(1);
$monrecord->montitre = 'Olléééé';

$dao->save($monrecord);

la difference est (laurent me corrigera) que jDao utilise des methodes statiques.

Je ne sais pas ce que cela apporterait de ne plus les rendre statiques.

Merci Foxmask pour ta réponse.

Je savais néanmoins que les méthodes findAll() ou get() existent.

Mon interrogation porte sur la syntaxe.

Actuellement, on passe en argument un record à une méthode d'un DAO, alors que la plupart des API proposent les mêmes méthodes directement sur le record, ce qui est plus intuitif (cf. mes exemples).

DAO est un design pattern. Toi tu veux un design pattern de type Active record. Passer à l'active record change complètement la philosophie de la couche "model", et nécessite de tout réécrire. Du coup jDao ne devrait plus s'appeler jDao...

Enfin bref. Je ne suis pas contre d'avoir un autre type de "model", mais il y a du boulot...

ce qui est plus intuitif

Ton argument est totalement subjectif... :-p

Peut être que Dimitri01 n'a pas utilisé le bon mot avec intuitif :) Ce qui serait réel c'est une "simplification" dans la syntaxe d'appel pour un même service rendu. Mais comme le dit Laurent, tout est faisable, seulement il faut le coder.

Après un framework est (à mes yeux) censé aider le développeur à :

• ne pas réinventer la roue
• avoir une base de procédures/fonctions "sûres" sur lesquelles s'appuyer
• simplifier la syntaxe de programmation pour permettre une programmation plus efficace

L'outil existant est déjà très bien et l'utilisation actuelle est cohérente avec la logique expliquée par Laurent, après, le code étant ouvert, rien ne t'empêche de faire mieux :)

Du coup jDao ne devrait plus s'appeler jDao...

Et ce serait quoi son nouveau nom?

jActiveRecord ?

jModel ? jOrm ? vendor\framework\jelix\lib\orm\activerecord\record ? :-D

J'ai tellement aimé la suggestion de Dimitri01 que je ne pouvais plus attendre avant de la coder.

Des que je l'ai vue, je me devais de la faire.

En faite ça m'agacer un peu le fait de creer une instance jDao::get en plus de jdao::createRecord plus la ligne $dao->insert($record);

		$record = jDao::createRecord(self::$daoname);
		
		#	bind the record with data

		 $record->bind($data);

		#	insert the record
		$record->save();

		# maintenant on a plus besoin d'écrire ceci
		//$dao = jDao::get(self::$daoname);
		//$dao->insert($record);

J'ai uploader les changements sur Github

https://github.com/jelix/jelix/pull/31 -> mod sur le jDaoRecordBase.class.php https://github.com/jelix/jelix/pull/32 -> mod sur le jDao.class.php