Condenser mon code

Version imprimable

Condenser mon code

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:

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 ?

Hello,

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

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 :)

++

06/11/2014, 09h23
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.
06/11/2014, 09h26
blugeen

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

Et je vais me renseigner sur cette histoire de Traits.
06/11/2014, 11h35
Flopp

Pour utiliser les Traits réguliérement, et bin c'est vraiment Traits bien ;-)
06/11/2014, 17h30
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.
07/11/2014, 01h22
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 :P

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

Code:

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:

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é