Discussion :

[Nikowa]

Bonjour,

Je m’excuse d'avances pour les fautes d'orthographe (je suis en train de relire le tout afin de re re re corriger) .
J'ai corrigé et j'espère ne pas avoir oublié trop de fautes :/)

Voilà j'ai commencé à lire des cours sur Symfony 2 il y a 2 semaines.
Je suis en train de commencer à faire mes propres tests ainsi qu'une petite liste de mémo rapide des noms des fonctions etc. afin de ne pas devoir chercher à chaque fois la moindre petite syntaxe exacte sur internet.

Mon problème, c'est l'organisation de Symfony 2.
Je ne vais pas la remettre en cause, elle est super !
Néanmoins, je ne veux pas m'en égarer, afin que n'importe qui puisse revenir sur mon code sans soucis.
J'aimerais donc que des personnes plus expérimenté que moi me commente, conseil, me disent mes grosses erreurs.

Mon premier micro site pour tester un peu la chose :

- Un bundle de base qui affiche une page static suivant le nom en url
- Un système de commentaire sous forme de service
- Un backoffice permettant de lister les commentaires



Pour le bundle de base, pas de soucis, c'est celui généré automatiquement.



Le système de commentaire :
J'ai pu voir que certain l'intégre à leurs bundles

avantage: ils peuvent lier la liste de commentaire à leur objet (un article par exemple) avec une relation Many To One proprement et ainsi laisser le bundle indépendant.
Désavantage : il faut refaire le système commentaires pour chaque bundle.

C'est pourquoi j'ai pensé que faire un système de commentaire sous forme de service pourrait être pas mal, qu'en pensez vous ?

Après avoir un peu galéré, j'ai réussi à le faire.
J'ai créé un bundle "CommentsBundle"
Dedans, j'ai supprimé le controller et les routes, inutile étant donné qu'il n'est que pour un service
J'ai créé un répertoire et j'ai mis mon service dedans
J'ai créé 2 entités:

-Commentaires ( Objet qui relies tout les commentaires d'un même)
"section" -> string libre pour dire la section où se trouve le commentaire
"parent_id" -> int qui donne l'id de l'objet de la section ou il se trouve

-Commentaire ( un commentaire simple, pseudo, date, message, ainsi que l'objet parent "commentaires" )

Voici ce que j'obtiens pour afficher le service de commentaire dans une page d'un bundle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
		// Charge le service de commentaires
                $commentaires = $this->container->get('nino_comments.comments');
		// Charge les commentaires associé a la page 25, si premier chargement il créait alors l'objet en "commentaires" en bdd
		$commentaires->chargerCommentaires("page",25);
		// Récupére le formulaire généré avec le formBuilder
		$form = $commentaires->getFormulaire();
		// Récupére la liste des derniers commentaires
		$coms = $commentaires->getCommentaires();

Et voici le service : ( pour une meilleur vue cliquez ici )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
<?php
 
// src\Nino\CommentsBundle\Comments\NinoComments.php
 
namespace Nino\CommentsBundle\Comments;
 
use Doctrine\Bundle\DoctrineBundle\Registry;
use Symfony\Component\DependencyInjection\ContainerInterface as Container;
use Nino\CommentsBundle\Entity\Commentaires;
use Nino\CommentsBundle\Entity\Commentaire;
 
class NinoComments
{
    /**
     * @var Doctrine\Bundle\DoctrineBundle\Registry
     */
    protected $doctrine;
	protected $container;
 
	public $coms;
	public $com;
 
    public function __construct(Registry $doctrine,Container $container)
    {      
		// chargement de doctrine et du container
        $this->doctrine = $doctrine;
		$this->container = $container;
    }
 
 
	public function chargerCommentaires($section,$parent){
 
		// récupération du manager
		$em = $this->doctrine->getManager();
 
		// récupération du repository de "commentaires"
		$repository = $em->getRepository('NinoCommentsBundle:Commentaires');
 
		// récupération de l'objet com pour la section et ça page
		$this->com = $repository->findOneBy(array('section' => $section,'parentId' => $parent));
 
		// vérification que l'objet existe
		if (!$this->com) {
			// s'il n'existe pas alors on le créer.
			$this->com = new Commentaires();
			$this->com->setSection($section);
			$this->com->setParentId($parent);
			// persist puis flush pour sauvegarder
			$em->persist($this->com);
			$em->flush();
			// liste de commentaires vide vue qu'il est nouveau
			$this->coms = array();
		}else{
 
			// sinon on charge le repository "commentaire"
			$repository = $em->getRepository('NinoCommentsBundle:Commentaire');
			// et on récupére les 5 derniers commentaires associés a l'objet "commentaires"
			$this->coms = $repository->findBy(array('commentaires'=>$this->com),array('date' => 'desc'),5,0);
 
		}
 
	}
	// function trouvé sur internet afin de pouvoir utiliser le form builder depuis un service
	public function createFormBuilder($data = null)
    {
        return $this->container->get('form.factory')->createBuilder('form', $data);
    }	
 
	public function getFormulaire(){
 
		// Je récupére l'objet commentaire afin de créer le formulaire a partir de son entité
		$commentaire = new Commentaire();
		$form = $this->createFormBuilder($commentaire);
		$form
			->add('pseudo','text')
			->add('content','textarea');
 
		// Je récupére la requete
		$request = $this->container->get('request');
		if ($request->getMethod() == 'POST') {
 
			// récupération des données du formulaire
			$formData=$request->request->get('form');
			// je met ces données dans mon objet
			$commentaire->setPseudo($formData['pseudo']);
			$commentaire->setContent($formData['content']);
			// je met comme objet parent le "commentaires" actuel
			$commentaire->setCommentaires($this->com);
			// je charge le manager d'entité puis sauvegarde ce commentaire
			$em = $this->doctrine->getManager();
			$em->persist($commentaire);
			$em->flush();
 
			// j'ajoute un flash bag pour afficher que le commentaire est ajouté
			$this->container->get('session')->getFlashBag()->add('info', 'Commentaire bien ajouté');
		}
 
		// je récupére le formulaire puis le retourne au bundle afin de l'afficher dans la vue 
		$form = $form->getForm();
		$form =  $form->createView();
		return $form;
 
	}
 
	// retourne la liste des commentaires
	public function getCommentaires(){
		return $this->coms;
	}
}
?>

Mes principales questions et problème :
Est ce que je m'y suis pris correctement ?
Il y a t'il plus simple pour récupérer doctrine, ou le container ?
Pour le formulaire, j'ai un peu galéré étant donné que je ne suis pas dans un controller, il y a t'il une meilleur méthode ou une plus simple ?
(J'ai vu qu'il y avait une methode $form->bind() afin de récupérer le formulaire, mais impossible de la faire marcher ici)
Pour ce qui est de la méthode utilisée, j'ai vu que l'on peut inclure un controller dans twig, est ce que je ne devrais pas plutôt faire mon service de commentaire sous forme de controller, et l'inclure ainsi dans les pages ?




Le backoffice :
J'ai créé un bundle "AdminBundle" avec un préfix /admin pour les routes
Chaque partie de l'admin aura donc son controller dédié à un bundle à gérer

Voici par exemple mon controller pour les commentaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
<?php
 
namespace Nino\AdminBundle\Controller;
 
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Nino\CommentsBundle\Entity\Commentaire;
 
class CommentsController extends Controller
{
    public function indexAction()
    {
		$em = $this->getDoctrine()->getManager();
		$repository = $em->getRepository('NinoCommentsBundle:Commentaire');
		$last = $repository->getLastCom();
        return $this->render('NinoAdminBundle:comments:index.html.twig',array('coms'=>$last));
    }
}

Mes questions :
Y a t'il une meilleur methode ou autre méthode pour créer le backoffice ? (a par les systèmes automatiquement qui ne pourrait convenir pour des clients)

Si jamais vous avez des conseilles, ou de bons liens pour prendre rapidement symfony en main, et ne pas s'égarer dans l'organisation, je suis prenant.
J'ai pas mal galéré avec des dépendances manquantes aussi (doctrine pour commencer, puis le container, et enfin le form builder >.<), donc si jamais vous avez de bons liens là-dessus, ça serait super.


Je remercie grandement tous ceux qui prendront le temps de lire, et qui me conseilleront.

[Soullivaneuh]

Bonjour,

Pour le backoffice, SonataAdminBundle ca ne correspondrait-il pas a tes attentes ? http://sonata-project.org/bundles/admin

Sinon, les fonctions/methodes/variables en francais sont a proscrire !

[matlow]

Déjà bon courage, t'es motivé c'est le principal !

Peux-tu nous dire le thème du projet dans l'ensemble. As tu créé ton model au complet ?
Ton micro-test reprend plein de concepts de sf2, c'est pas évident d'en voir l'utilité.
Je verrai plutôt le Commentbundle comme un simple service (type factory ?) au sein d'un bundle plus large (du genre BlogBundle) et un peut-être 2 autres bundle si besoin : un pour l'admin (// sonataAdmin) et un pour la gestion des users (// sonataUser)

A+