Discussion :

[blugeen]

Bonjour,

Le titre n'est pas bien explicite mais je ne savais pas trop comment nommer mon problème.

J'ai trois entités principales : TypeA et TypeB reliées en ManyToOne à User.

J'ai deux entités "intermédiaires" : UserTypeA et UserTypeB, qui contiennent les attributs des relations ManyToOne (par exemple, la note qu'un utilisateur a attribué à un produit de type A). Ces deux entités et leur repository sont identiques (sauf que l'une est reliée à TypeA et l'autre à TypeB).

Le problème est que je n'arrive pas à condenser mon code dans mon controller :

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
public function typea_noterAction(TypeA $typea)
{
   $user = $this->getUser();
   $userTypeA = $this->getDoctrine()
                      ->getManager()
                      ->getRepository('GamUserBundle:UserTypeA')
                      ->getNote($user, $typea);
 
   //Reste du code
}
 
public function typeb_noterAction(TypeB $typeb)
{
   $user = $this->getUser();
   $userTypeB = $this->getDoctrine()
                      ->getManager()
                      ->getRepository('GamUserBundle:UserTypeB')
                      ->getNote($user, $typeb);
 
   //Reste du code
}

Le reste du code est identique (en remplaçant juste TypeA par TypeB). J'ai donc tout un tas de routes et tout un tas de code copier/coller dans mon controller. Y aurait-il un moyen d'éviter ça ? De même pour mes entités intermédiaires et leur repository, c'est juste un gros copier/coller, est-ce possible condenser ça ?

[Nico_F]

Hello,

Je te suggèrerais de commencer par faire une entité abstract qui contient tous les attributs et deux classes qui l'étendent.

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
 
/**
 * @ORM\Table(name="Table_Type")
 * @ORM\Entity(repositoryClass="Path/To/RepositoryClass")
 * @ORM\InheritanceType("SINGLE_TABLE")
 * @ORM\DiscriminatorColumn(name="type", type="string")
 */
abstract class TypeAbstract {
    /**
     * @ORM bla bla bla
     */
    protected $user;
}
 
/**
 * @ORM\Entity
 */
class TypeA extends TypeAbstract {
    /**
     * @ORM pif paf pouf
     */
    protected $note;
}
 
/**
 * @ORM\Entity
 */
class TypeB extends TypeAbstract {
    /**
     * @ORM poc poc poc
     */
    protected $note;
}

Cette partie te permettra de jouer avec la classe abstraite pour tout ce qui concerne les deux types.
Une colonne sera rajoutée à la table pour que l'ORM puisse mapper les données sur une entité ou l'autre.

Ils partagent maintenant le même repository, donc tu peux condenser

++

[Watilin]

Je partage l'opinion de Nico_F : un parent commun aux deux classes est la solution la plus évidente.

Alternativement, PHP propose un mécanisme appelé Traits. Pour faire simple, un trait, c'est un paquet de fonctions regroupées par thème, qu'on peut attacher aux classes qu'on veut. Les traits sont inspirés des mixins qu'on trouve dans d'autres langages.

[blugeen]

Merci, ça va déjà bien réduire mon code !

Et je vais me renseigner sur cette histoire de Traits.

[Flopp]

Pour utiliser les Traits réguliérement, et bin c'est vraiment Traits bien ;-)

[Nico_F]

J'émets tout de même une réserve quand à l'utilisation des Traits, dans la mesure ou ils répondent à des problématiques que PHP ne gére pas, notamment l'héritage multiple.
Ils sont donc une alternative (élégante ou pas je ne sais pas, je n'ai pas vraiment d'avis dessus) à des extensions ou des helpers de classes.

En revanche, dans la mesure ou sa problématique peut être résolue avec une modèle bien pensé et de l'héritage simple, j'opterais tout de même pour de l'héritage plutôt que l'utilisation de Traits (option de facilité). Qui plus est si, pour partager une seule table et un seul repository, on doit de toute manière passer de l'héritage.

[Watilin]

Voilà un avis plein de sagesse

Pour moi les traits c'est séduisant parce que c'est rapide à mettre en place et ça demande peu de réflexion. Ça colle avec l'aspect script de PHP et sa fameuse tolérance (typage dynamique, erreurs laxistes, etc.). C'est bien pour les fois où on n'a pas envie de se creuser la tête, quand on veut faire quick and dirty

[Flopp]

Perso j'utilise les traits pour garder une cohérence entre mes entités qui partagent des attributs communs

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
trait BasicUserEntity
    {
        /**
         * @var string
         * @ORM\Column(name="email", type="string", nullable=true, unique=true)
         * @Assert\NotBlank()
         */
        protected $email;
 
        /**
         * @ORM\Column(name="first_name", type="string", nullable=true)
         * @Assert\NotBlank()
         */
        protected $firstName;
 
        /**
         * @ORM\Column(name="last_name", type="string", nullable=true)
         * @Assert\NotBlank()
         */
        protected $lastName;
    }

Code :

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

1
2
3
4
5
6
7
8
9
Class User extends AbstractUser
    {
        use BasicUserEntity, TimestampableEntity
    }
 
Class Address
    {
        use BasicUserEntity
    }

du coup je peux définir les asserts dans mon trait, je trouve que ça apporte une flexibilité très intéressante pour tout ce qui est destiné à être réutilisé