Le 28 juillet 2010
Ce tutoriel est le 4eme d’une longue série, si vous ne l’avez pas déjà fait je vous conseille de lire les tutoriels en commençant par le sommaire de cette série.
Nous avons précédemment crée un module avec un contrôleur, un block et son Template associé. Notre module fonctionne bien et je pense que vous avez bien compris comment ca marche jusqu’ici. J’en profite pour vous remercier de vos retours très positifs qui me motivent pour continuer cette série de tutoriels.
Maintenant, un module qui fait l’équivalent d’un echo c’est pas très utile et ca a rien de très compliqué vous l’avez vu. Dans ce tutoriel on va modifier notre module pour qu’il aille chercher des données dans notre base de données (sous Mysql) pour les afficher dans notre Block.
Etape 1 : Créer la table
On va dire que notre module est un carnet d’adresse, on veut que le bloc affiche toutes les adresses du carnet les unes à la suite des autres de la forme :
Nom Prenom numero_de_telephone
Exemple :
Jean Dupond 0000000000
Jean Dupond 0000000000
Jean Dupond 0000000000
Jean Dupond 0000000000
…
On crée donc une table dans la base de donnée, on va appeler cette table pfay_test.
On exécute donc la requête suivante :
CREATE TABLE `magento`.`pfay_test` (
`id_pfay_test` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`nom` VARCHAR( 50 ) NOT NULL ,
`prenom` VARCHAR( 50 ) NOT NULL ,
`telephone` VARCHAR( 20 ) NOT NULL
);
Votre table est maintenant dans la base de données. Pour pouvoir interagir avec, on va créer le model.
Etape 2 : Déclarer le model dans config.xml
Vous le savez, Magento utilise le model MVC, il faut donc créer un model pour pouvoir intérragir avec notre base de donnée.
A votre avis pour créer un Model, vous qui avez suivi les 3 tutoriaux précédent…qu’est ce qu’on va devoir faire ? Vous avez la réponse qui sort automatiquement de votre tête car vous commencez à avoir l’habitude ^^, on va d’abord déclarer le model dans le fichier config.xml de notre module.
Allez donc dans etc/config.xml et rajoutez dans <global> âpres la déclaration <blocks>:
<models>
<test>
<class>Pfay_Test _Model</class>
<resourceModel>test_mysql4</resourceModel>
</test>
<test_mysql4>
<class>Pfay_Test_Model_Mysql4</class>
<entities>
<test>
<table>pfay_test</table>
</test>
</entities>
</test_mysql4>
</models>
<!-- permet au module de lire et ecrire -->
<resources>
<!-- connection pour ecrire -->
<test_write>
<connection>
<use>core_write</use>
</connection>
</test_write>
<!-- connection pour lire-->
<test_read>
<connection>
<use>core_read</use>
</connection>
</test_read>
</resources>
<!-- -/- -->
Dans <test> :
On déclare ici que les models seront dans le répertoire app/code/local/Pfay/Test/Model/ et que la « ressource » c’est-à-dire la chose utilisé pour aller chercher les données par le model sera défini par test_mysql4
Dans <test_mysql4> on défini que les classes seront dans app/code/local/Pfay/Test/Model/Mysql4/ et qu’une entité test représentera la table pfay_test qu’on a crée précédemment dans la base de donnée.
Etape 3 : Créer le Model
Une fois votre Model déclaré, vous pouvez maintenant créer les fichiers.
Créez donc les 3 dossiers suivant :
app/code/local/Pfay/Test/Model/
app/code/local/Pfay/Test/Model/Mysql4/
app/code/local/Pfay/Test/Model/Mysql4/Test/
Ensuite, dans app/code/local/Pfay/Test/Model/ créez un fichier Test.php qui contiendra le code suivant :
<?php
class Pfay_Test_Model_Test extends Mage_Core_Model_Abstract
{
public function _construct()
{
parent::_construct();
$this->_init('test/test');
}
}
Ceci est votre model Test, vous lui indiquez que c’est une entitée test de votre module test.
Allez ensuite dans le dossier app/code/local/Pfay/Test/Model/Mysql4/ et créez un fichier Test.php qui contiendra :
<?php
class Pfay_Test_Model_Mysql4_Test extends Mage_Core_Model_Mysql4_Abstract
{
public function _construct()
{
$this->_init('test/test', 'id_pfay_test');
}
}
C’est ici que vous indiquez a Magento que votre model test/test va utiliser comme clef primaire le champ id_pfay_test. (Faites bien attention a ce que ce champ soit en auto increment et qu’il soit la primary key de votre table.
Allez ensuite dans le dossier app/code/local/Pfay/Test/Model/Mysql4/Test/ et créez un fichier Collection.php qui contiendra :
<?php
class Pfay_Test_Model_Mysql4_Test_Collection extends Mage_Core_Model_Mysql4_Collection_Abstract
{
public function _construct()
{
parent::_construct();
$this->_init('test/test');
}
}
Ce fichier sert a définir la collection pour votre model test/test.
Vous ne comprenez peu être pas bien a quoi tout ceci sert, il faut absolument que vous reteniez cette procédure pour créer un modèle sous Magento. Une fois ces fichiers crée, vous pouvez utiliser votre model pour interagir avec vos tables très facilement.
Etape 4 : Lister les contacts dans notre Block
Rappelez vous, dans le tutorial précèdent nous avions créer un block dans app/code/local/Pfay/Test/Block qui s’appelait Monblock.php. Nous allons le modifier pour qu’il affiche la liste des contacts dans la base de donnée.
Tout d’abord, insérez quelques lignes dans votre table pfay_test de votre base de données.
Ensuite, modifier votre Monblock.php de la manière suivante :
<?php
class Pfay_Test_Block_Monblock extends Mage_Core_Block_Template
{
public function methodblock()
{
//on initialize la variable
$retour='';
/* on fait une requette : aller chercher Tous les elements
de la table pfay_test (grace à notre model test/test
et les trier par id_pfay_test */
$collection = Mage::getModel('test/test')->getCollection()
->setOrder('id_pfay_test','asc');
/* ensuite on parcours le resultat de la requette et
avec la fonction getData(), on stocke dans la variable retour
(pour l’affichage dans le template) les données voulues */
foreach($collection as $data)
{
$retour .= $data->getData('nom').' '.$data->getData('prenom')
.' '.$data->getData('telephone').'<br />';
}
//je renvoi un message de succes a l'utilisateur (juste pour que vous sachiez utiliser la fonction)
Mage::getSingleton('adminhtml/session')->addSuccess('Cool Ca marche !!');
return $retour;
}
}
En regardant le code, je pense que vous comprendrez vite ce qu’on a fait grâce aux commentaires, si ce n’est pas le cas n’hésitez pas a laisser un commentaire
Testez maintenant votre code en allant sur http://votresite.com/test/index et vous voyez maintenant s’afficher votre liste de contacts.
Vos devoirs :
Essayez de refaire un module à partir de rien avant d’entamer le prochain tutoriel vous devez savoir refaire les 4premiers tutoriels les doigts dans le nez avant de pouvoir entamer la suite ;)
Entrainez-vous vraiment, refaites un nouveau module pour gérer votre bibliothèque de film par exemple. Ca ressemble fortement a ce qu’on vient de faire mais ce n’est pas pareil donc vous allez pouvoir mettre en pratique et vraiment comprendre ce que vous faites. Bon courage ;)
Fin de ce tutoriel
Dans le prochain tutoriel, on rentrera un peu plus en détails sur comment fonctionne les collections afin que vous puissiez rapidement faire des opérations plus complexes sur votre base de donnée.
Voila c’est la fin de ce tutoriel, j’espère que ce tutoriel N°4 vous a plus, vous savez maintenant interagir avec la base de donnée dans vos extensions Magento. N’hésitez pas à laisser des commentaires si vous avez des questions ou des remarques 
Retrouvez le sommaire de ce tutoriel
Le 27 juillet 2010
Ce tutoriel est le 3eme d’une longue série, si vous ne l’avez pas déjà fait je vous conseille de lire les tutoriels en commant par le sommaire de cette série. Nous avons précédemment crée un module, nous allons maintenant apprendre a créer et afficher un Block magento.
Pourquoi créer un block ?
Pour l’instant, votre module est un peu « simple », vous pouvez exécuter des traitements mais son utilité est assez limitée. Nous allons maintenant apprendre à afficher du contenu en utilisant un template, c’est a ca que sert un block ;)
Comment ca marche ? ok on va faire un petit rappel :
le controller, appelle votre layout pour savoir ce qu’il doit afficher, dans ce layout, vous placez des blocks qui sont en fait une sorte de « mini controller » (qui vont par exemple récupérer une liste de client). Ces blocks font ensuite appel a des templates pour afficher leurs informations.
Maintenant que vous avez compris comment ca marche, la seule façon de comprendre c’est de le faire alors allons y !
Etape 1 : Appeler le layout dans le controller
Pour rappel, votre module se situe dans /app/code/local/Pfay/Test/. Le nom du module est donc Test et il se trouve dans le namespace Pfay
Allez maintenant ouvrir votre controller :
/app/code/local/Pfay/Test/controllers/IndexController.php
Et le modifier comme ceci :
class Pfay_Test_IndexController extends Mage_Core_Controller_Front_Action
{
public function indexAction()
{
$this->loadLayout();
$this->renderLayout();
}
public function mamethodeAction()
{
echo ‘test mamethode’;
}
}
Comme vous le voyez, j’ai rajouté dans mon action index, deux petites lignes. Ces lignes vont chercher ce qu’il faut afficher quand on arrive sur cette action (en allant a l’url http://votresite.com/test/index par exemple).
$this->loadLayout(); //Va chercher les elements à afficher
$this->renderLayout(); //Affiche les elements
Pour l’instant, il n’y a plus rien a faire sur le controller. Nous avons indiqué a notre controller qu’il doit aller chercher les informations dans le layout, allons maintenant voir ce qui se passe du coté du layout…
Etape 2 : Déclarer les éléments à afficher grâce au Layout.
Pour commencer avant de pouvoir utiliser le Layout, (et la si vous avez lu les tutoriaux précédents vous commencer a vous douter de la suite…) on doit le déclarer, c’est-à-dire, déclarer a magento qu’il va pouvoir l’utiliser et qu’il existe. Pour cela allons dans notre fichier config.xml. (qui se trouve dans le repertoire /etc de votre module).
Ouvrez le et rajoutez y dans <frontend> et apres <routers> :
<layout>
<updates>
<test>
<file>test.xml</file>
</test>
</updates>
</layout>
Ce petit bout de code en xml vous permettra de déclarer votre fichier test.xml comme étant le layout de votre module Test (parce qu’il est dans le config.xml de votre module Test)
Maintenant, déclarons le dossier ou vont se trouver les Blocks :
Dans <config> et âpres <frontend> rajoutez maintenant :
<global>
<blocks>
<test>
<class>Pfay_Test_Block</class>
</test>
</blocks>
</global>
Dans <global> vous déclarez vos Blocks, c’est aussi ici que vous déclarerez par la suite vos Model et vos Helpers (on verra plus tard ce que c’est).
Remarque importante :
Sous Magento quand vous déclarez vos classes, le nom de votre classe correspond au chemin vers ce fichier, ainsi notre controller Pfay_Test_IndexController se à l’adresse suivante : /app/code/local/Pfay/Test/indexController.php
Vous en déduisez donc que les noms de vos Blocks seront du type Pfay_Test_IndexController_MonBlock
Maintenant que le fichier config.xml est configuré et que magento est capable de trouver notre layout et nos blocks, allons voir ce qui se passe du coté du Layout !
Le layout :
si vous vous souvenez bien, dans la première leçon de ce tutoriel, nous avions vu qu’un module contient une partie code et une partie template qui se trouvent a deux endroits différents dans les répertoires de magento.
Le layout fait partie de la partie « template », nous avons déclaré dans le config.xml de notre module qu’il s’apellera test.xml
Allez maintenant dans le repertoire layout de votre théme Magento.
Dans notre exemple, le template utilisé actuellement dans magento se trouvera dans le repertoire suivant: \app\design\frontend\pfay\theme\ .
Nous allons donc créer un Layout text.xml dans le repertoire \app\design\frontend\pfay\theme\layout\
Une fois ce fichier crée, éditez le et copiez dedans :
<layout version="0.1.0">
<default>
<reference name="content">
</reference>
</default>
<routeurfrontend_index_index>
<reference name="content">
<block type="test/monblock" name="afficher_monbloc"
template="test/afficher.phtml" />
</reference>
</routeurfrontend_index_index>
</layout>
Je ne vous explique pas comment cela fonctionne, si vous ne comprenez pas ce code je vous conseiller d’aller lire le guide du designer magento et d’etre au point la dessus avant de commencer a essayer de développer un module.
Je vais quand même vous rappeler a quoi servent quelques bout de code au cas où ;)
<routeurfrontend_index_index>
…
</routeurfrontend_index_index>
Pour indiquer a magento quels blocks rajouter dans quelle page, on a créer le Layout !
Ce layout defini des pages, a l’intérieur de ses pages, on ajoute ses blocks. Une page s’écrit de la forme suivante : « nom du routeur »_ « nom du controller »_ « nom de l’action »
Ainsi quand on veut accéder à notre action http://votresite.com/test/index, on a défini dans le config.xml le nom du routeur a routeurfrontend, on sait que le controlleur appelé dans ce cas la est le controller IndexController.php, et que la méthode appelée sera IndexAction().La page sera donc dans le layout représenté par la balise : routeurfrontend_index_index
Et on mettra à l’intérieur l’instruction :
<block type="test/monblock" name="afficher_monbloc" template="test/afficher.phtml" />
Qui signifiera pour magento « crée un block que tu iras chercher dans le module Test, qui s’apellera « monblock » et qui utilisera le template « afficher.phtml » qui se trouvera dans le dossier « test » du dossier « template ».
Etape 3 : Créer le block
Maintenant, il faut créer le block « monblock », allez donc dans le dossier que vous avez défini dans le config.xml pour stocker vos blocks (app/code/local/Pfay/Test/Block) et créer le fichier Monblock.php dedans.
Ce fichier contiendra :
<?php
class Pfay_Test_Block_Monblock extends Mage_Core_Block_Template
{
public function methodblock()
{
return ‘informations de mon block !!’ ;
}
}
Ce fichier n’est juste qu’une classe de type Block (Mage_Core_Block_Template) avec une méthode methodblock() qui retourne une phrase (de type String)
Etape 4 : Créer le template
Allez maintenant dans le répertoire \app\design\frontend\pfay\theme\template\
Et créer un répertoire « test » avec à l’intérieur un fichier afficher.phtml.
Ce fichier contiendra :
<?php
echo $this->methodblock();
?>
Comment ca marche ?
On a defini un block de type “test/monblock” dans le layout, qui fait appel a notre template afficher.phtml, on peu donc accéder dans afficher.phtml aux méthodes de notre block grace a la variable $this
Etape 5 : Tester !!
Allez maintenant sur http://votresite.com/test/index et vous voyez maintenant s’afficher votre site avec comme contenu un texte : « informations de mon block !! »
Fin de ce tutoriel ?
Maintenant, vous pouvez insérer de block avec ce template dans n’importe quelle page de votre site J. Notre exemple est simple car le but est de comprendre comment fonctionne Magento donc notre block n’a pas vraiment d’utilité.
Un block sert en général a faire des traitements du style lister les 5 derniers produits ajouté dans votre boutique Magento, afficher un formulaire de contact ou un formulaire pour faire un devis rapidement…tous ces blocks vous seriez content de pouvoir les remettre a plusieurs endroits de votre site juste en insérant une petite ligne dans votre Layout non ? Ok maintenant vous avez compris a quoi sert un block et comment en crée un ;)
Voila c’est la fin de ce tutoriel, j’espère que ce tutoriel vous a plus, n’hésitez pas a laisser des commentaires si vous avez des questions ou des remarques éventuelles ;)
Retrouvez le sommaire de ce tutoriel
Le 26 juillet 2010
Ce tutoriel est le 2eme d’une longue série, vous allez maintenant apprendre a créer votre controller sous Magento. Si vous n’avez pas lu les premiers articles, je vous conseille fortement de le faire.
Sous magento, vous accedez a votre controller via l’url : http://votresite.com/module/methode/
Vous commencez donc par créer votre module :
1- Créer le dossier dans /app/code/local/Pfay/Test/
Vous créez ainsi votre namespace Pfay et votre module Test.
2- Activez le module dans magento :
Ajoutez un fichier Pfay_all.xml dans /app/etc/module/
Et inserez dedans le code suivant
<?xml version="1.0"?>
<config>
<modules>
<Pfay_Test>
<active>true</active>
<codePool>local</codePool>
</Pfay_Test>
</modules>
</config>
Ce fichier permet de déclarer tous les modules de votre namespace Pfay, vous mettrez entre le balises « modules » vos déclaration de modules les unes a la suite des autres.
<Pfay_Test>
<active>true</active>
<codePool>local</codePool>
</Pfay_Test>
Pfay_Test vous permet de déclarer le module Test de votre namespace Pfay.
active : true = le module est active
false = le module n’est pas activé
codePool : Le module se trouvera dans le dossier local car c’est un module que nous avons créer nous même (rappelez vous la lecon 1).
Magento trouvera donc les fichiers de ce module dans le dossier /app/code/local/Pfay/Test/
Maintenant, créons le controller :
allez dans /app/code/local/Pfay/Test/
1- Créer le dossier /app/code/local/Pfay/Test/controllers/
2- A l’intérieur créer un fichier IndexController.php qui contiendra :
class Pfay_Test_IndexController extends Mage_Core_Controller_Front_Action
{
public function indexAction()
{
Echo ‘test index’ ;
}
public function mamethodeAction()
{
Echo ‘test mamethode’;
}
}
Maintenant, si vous allez sur http://votresite.com/test/index que ce passe t’il ?
Effectivement…vous ne trouvez pas la page, il y a une erreur car vous n’avez pas encore déclaré le controller dans le module.
Config.xml, le fichier pour configurer votre module :
De la même manière que vous avez déclaré votre module pour que magento le prenne en compte dans Pfay_All.xml , il faut que dans le fichier config.xml de votre module, vous déclariez aussi votre controller dans le fichier config.xml de votre module.
Mangento va ainsi trouver votre fichier Pfay_All.xml, il va aller dans votre dossier /app/code/local/Pfay/Test/etc/ et va lire le fichier config.xml pour savoir ou aller chercher votre controlleur et comment fonctionne votre module.
Créez donc dans votre dossier Test, un dossier etc/ avec dedans config.xml.
config.xml contiendra :
<?xml version="1.0"?>
<config>
<modules>
<Pfay_Test>
<version>1.0.0</version>
</Pfay_Test>
</modules>
<frontend>
<routers>
<routeurfrontend>
<use>standard</use>
<args>
<module>Pfay_Test</module>
<frontName>test</frontName>
</args>
</routeurfrontend>
</routers>
</frontend>
</config>
Explications :
<modules>
<Pfay_Test>
<version>1.0.0</version>
</Pfay_Test>
</modules>
Dance cette partie, on declare l’identité du module, pour que magento puisse vérifié que le module que vous avez declare dans votre fichier Pfay_All.xml est bien celui la et le numéro de version vous permet les mises a jour de votre module.
<routers>
<routeurfrontend>
<use>standard</use>
<args>
<module>Pfay_Test</module>
<frontName>test</frontName>
</args>
</routeurfrontend>
</routers>
Vous permet de déclarer un routeur « routeurfrontend » qui est en fait la route utilisé par magento pour accéder a votre controlleur.
Dans notre exemple, le routeur est de type « standard », (c’est-à-dire que c’est un module qui s’affichera sur le frontend).
Le nom du module est Pfay_Test et le raccourci pour y accéder via l’url est test ainsi quand on tapera
http://votresite.com/test/index, on arrivera sur la méthode index de votre controlleur IndexController.php (de votre dossier controllers)
Vous pouvez aussi y accéder en utilisant votre routeur a la place du frontName.
http://votresite.com/ routeurfrontend/index/
Testez maintenant votre module :
http://votresite.com/test/index vous renvoie : « test index »
http://votresite.com/test/mamethode vous renvoie : « test ma methode »
Vous savez maintenant créer un controller. Essayez maintenant de bien comprendre ceci en le refaisant chez vous et ca devrai aller pour passer a la suite.
Si vous avez des questions, n’hésitez pas a laisser un commentaire.
Retrouvez le sommaire de ce tutoriel
Le 23 juillet 2010
Sous Magento, vous avez peu être l’habitude (et c’est une très mauvaise habitude) de mettre dans vos templates les chemins vers vos images directement dans le code.
Mais sous magento , vous pouvez utiliser des fonctions qui faire le travail a votre place.
La fonction getBaseUrl est la pour ca, vous pouvez lui passer en arguments les constantes qui viennent de la classe Mage_Core_Model_Store qui représente le dossier que vous voulez retrouver. Cette fonction retourne un String donc n’oubliez pas de l’utiliser de la fonction echo.
Les différents retour possible :
Mage::getBaseUrl();
// http://votresite.com/index.php/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_JS);
// http://votesite.com/js/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_LINK);
// http://votresite.com/index.php/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_MEDIA);
http://votresite.com/media/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_SKIN.'images/');
// http://votresite.com/skin/images/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_SKIN);
// http://votresite.com/skin/
Mage::getBaseUrl(Mage_Core_Model_Store::URL_TYPE_WEB);
// http://votresite.com/
Et voila, maintenant vous savez générer le chemin vers votre dossier skin, votre dossier media, la racine de votre site ou encore le dossier JS.
Si vous avez des remarques ou des questions n’hésitez pas à laisser un commentaire.
Le 15 juillet 2010
Dans un premier tutoriel, je vous promettais de créer un tutoriel qui vous permettrez de créer un module complet sous Magento.
Les Notions de bases :
Avant de vous lancer dans l’aventure magento, vérifions déja que vous avez de solides bases en programmation.
Les prérequis pour développer sous magento sont :
- avoir déjà installé Magento.
- savoir ce qu’est le pattern MVC.
- connaitre l’orienté objet en PHP (et le PHP bien sur…)
- savoir comment marche le systeme de template de magento
Vous avez les 2 premiers mais n’avez pas le 3eme, allez sur : le guide du designer magento (voir aussi : la version francaise)
La structure d’un module Magento
Dans un module magneto il y a 2 parties, le « code » et les « templates ».
le code détermine les actions que le module va pouvoir réaliser, l’intérraction avec la base de donnée etc… alors que les templates sont juste des mise en page des données envoyé par le code.
Dans Magento, ces 2 parties seront placées à 2 endroits différents.
votre « code » sera dans
/app/code/local/monNameSpace/monNomDeModule/
alors que la partie « template » du module sera dans :
/app/design/frontend/monRepertoiredeTemplates/monTemplate ( pour la partie frontend )
Et
/app/design/adminhtml/monRepertoiredeTemplates/monTemplate ( pour la partie backend )
La partie « code » de mon template contiendra les elements suivants :
Block : la ou vous aller mettre la partie « controller » de votre block
Controllers : les controllers de votre module
Models : les models de votre module
Helper : les helpers de votre module
etc : la configuration de votre module
sql : les requettes sql a executé pour créer votre module lors de l’instalation
Petit rappel sur les blocks :
Dans Magento, un Block est un morceau de votre site qui marche « tout seul », vous pouvez l’insérer un peu n’importe ou. En fait, un block c’est une sorte de « mini controller » que vous pourrez ajouter n’importe ou dans votre site.
Selon la page de votre site, vous pourrez lui assignez des templates différents selons l’affichage que vous voulez lui donner.
Le dossier /app/code :
Dans ce dossier vous retrouverez 3 dossiers qui contiendront :
Community : les plugins que vous avez récupéré (sur magentoconnect par exemple).
Core : les modules par défaut de magento (A NE SURTOUT PAS MODIFIER)
Local : les modules que vous avez développés
Vos devoirs en attendant le prochain tutoriel :
Essayez de naviguer dans les dossiers de votre site pour comprendre ce que je vous raconte. Ouvrez les fichiers et essayez de les comprendre.
Conclusion du tutoriel :
Vous avez vu la structure des modules magento, si vous faites bien vos devoirs vous devriez comprendre un peu mieux.
Cela vous parait un peu abstrait pour l’instant ? C’est normal ! Ca fait beaucoup d’informations à la fois.
Dans le prochain tutoriel, nous allons commencer la création de notre premier module en créant le Controller.
Ne vous inquiétez pas, faites moi confiance : nous allons créer un module complet de A à Z, étapes par étapes. On va y aller doucement et vous verrez tout ce qui vous parait un peu abstrait dans ce premier tutoriel deviendra clair au fur et a mesure qu’on avancera.
Maintenant faites vos devoirs ! Bon courrage
Si vous avez des questions n’hésitez pas à poster un commentaire.
Retrouvez le sommaire de ce tutoriel
