Conception entités ManyToOne

Version imprimable

08/05/2013, 15h37
FaridM

Conception entités ManyToOne
Bonjour à tous,

Je développe un jeu simple et j'ai un problème lors de ma conception.

J'ai une entité Joueur et une entité Match.

Dans l'entité Match, j'ai besoin de 2 propriétés Joueur, attaquant et défenseur. Un Joueur ne peut-être que soit attaquant soit défenseur. A priori, chacune de ces propriété aurait une relation ManyToOne avec Joueur. Jusque là ça va. Seulement dans Joueur, pour avoir une relation bidirectionnelle, je vais rajouter une propriété Match avec une relation OneToMany (qui sera une ArrayCollection...), mais que dois-je mettre dans mappedBy :
Code:

1 2 3 /** * @ORM\OneToMany(targetEntity="Match", mappedBy="?????") */
Et je ne peux pas mettre 2 propriétés dans Joueur, cela représenterai la même chose et ça n'a pas de sens.

Merci.
10/05/2013, 10h52
FaridM

Pas d'idée?
13/05/2013, 07h18
FadeToBlack

Salut,

Une chose que je ne comprends pas :
Un joueur peut être soit attaquant soir défenseur, là çà va.:lol:

Mais en fait un joueur peut avoir unn statut différent suivant les différents match?
13/05/2013, 12h34
FaridM

Salut,

Non enfaite un Joueur est soit attaquant, soit défenseur quelque soit le match et un match contient forcément un attaquant et un défenseur.
13/05/2013, 13h19
FadeToBlack

Bah alors, je ne vois pas le problème :

Puisque le poste joueur dans les matchs est définitif, tu as donc un attribut poste , comme sexe ou couleurDesYeux. C'est une fois pour toute.

Du coup tu te retrouve avec simplement deux entités Joueur et Match avec une relation ManyToMany :
Un joueur peut disputer plusieurs match
un match est disputé par plusieurs joueurs.

Donc tu auras une table de liaison avec la combinaison de l'id du joueur et celui du match.

Je ne voit pas pourquoi tu aurais une entité Poste
13/05/2013, 18h30
FaridM

Oui comme ça sa marche. Ce que moi je voulais c'est bien différentier l'attaquand du défenseur dans l'entité Match et donc avoir des relations OneToMany, mais ce n'est peut-être pas possible.
13/05/2013, 18h46
FadeToBlack

En théorie tu pourrais le faire

Tu crées deux relations OneToMany de Joueur vers Match en faisant pointé tes attriubuts attaquants et défenseurs.

Cela est tout à fait possible techniquement mais j'ai perso deux raisons de ne pas le faire :
- tu as deux relations entre les mêmes entités,
- cette opération risque de ne pas être optimum d'un point de vu sql (Base de données).
13/05/2013, 22h57
FaridM

Ok, mais du côté de l'entité Joueur, afin d'avoir une relation bi-directionnelle, vers quoi je fais pointé la property match, puisque il y a 2 property différentes (attaquant et défenseur) ?
13/05/2013, 23h37
FadeToBlack

Mais non, tu n'as pas deux propriétés dans l'entité joueur, tu n'en as qu'une seule que l'on pourrait appeler "poste" et qui peut prendre que deux valeurs : Attaquant et Défenseur.
Comme si tu avais une propriété "Sexe" qui prend la valeur Homme ou Femme.

Ensuite tu baseras tes requêtes de telle façon à récupérer les attaquants, les défenseurs etc... voir avec d'autres critères si tu veux.

Tu vois ce que je veux dire ?
14/05/2013, 11h50
FaridM
Oui c'est pas de cette propriété que je parlais.

Dans Match j'ai attaquant et défenseur.

Pour avoir une relation bi-directionnelle, j'ajoute dans Joueur un propriété match (qui est un ArrayCollection), mais vers quelle propriété je dois faire pointer match? Dans le cas d'un défenseur, ce serai defenseur, et pour attaquant se serai attanquant, mais comme je n'ai qu'une propriété?

cf premier post.

Je met quoi dans le mappedBy ?
Code:

1 2 3 4 5 6 7 <?php /** * @ORM\OneToMany(targetEntity="Match", mappedBy="?????") */ private $match;

Tu aurais un mappedBy=joueurs.

Mais je ne copmprends pas la structure de tes entités. Est-ce que tu pourrais les mettre en entier (pas les setters and co).

Tu devrais avoir un truc comme cela non
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 34 class Joueur { // ... private $poste ..... /** * @ManyToMany(targetEntity="Match", mappedBy="joueurs") * @JoinTable(name="users_groups") */ private $matchs; public function __construct() { $this->matchs = new ArrayCollection(); } // ... } /** @Entity */ class Match { // ... /** * @ManyToMany(targetEntity="Joueur", inversedBy="matchs") */ private $joueurs; public function __construct() { $this->joueurs = new ArrayCollection(); } // ... }
Mais est-ce que tu as mis un attribut poste dans l'entité Joueur ?

Un joueur peut être attaquant dans un match et défenseur dans un autre ? D'après ce que tu m'as dit c'est non ?

Avec une relation ManyToMany ça fontionne. Moi ce que je voudrai c'est différentier l'attaquant du défenseur dans un match, ce qui me permettrait d'avoir 2 listes déroulantes dans le formulaire au lieu d'une liste multiple.

Ce que j'aimerai faire c'est ça :

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
34
35
 
<?php
 
public class Joueur
{
	/**
     * @ORM\OneToMany(targetEntity="Joueur", mappedBy="??????")
     */
    private $match;
 
	public function __construct() {
        $this->match = new ArrayCollection();
    }
 
}
 
 
 
 
public class Match
{
 
    /**
     * @ORM\ManyToOne(targetEntity="Joueur", inversedBy="match")
     * @ORM\JoinColumn(name="attaquant_id", referencedColumnName="id")
     */
    private $attaquant;
 
	/**
     * @ORM\ManyToOne(targetEntity="Joueur", inversedBy="match")
     * @ORM\JoinColumn(name="defenseur_id", referencedColumnName="id")
     */
    private $defenseur;
 
}

J'ai l'impression que ce n'est pas possible, est-ce que je me trompe?

14/05/2013, 15h18
FadeToBlack

Y'aurait une solution que je verrais comme çà mais vraiment bancale :

Tu remets dans ton match un attribut Joueurs qui sera en arraycollection.

Un attribut $Attaquant arrayCollection et un $défenseur en arrayCollection

Dans le constructeur ou un getters, tu assignes via une requete de ton repository :

Pour Attaquants : Les joueurs pour lequel Poste.joueur = 'attaquant' et
Pour défenseur : le même genre de résultat.

Effectivement ensuite dans ton form tu peux assigner deux listes déroulantes avec les résultats de ces requêtes.

Je trouve cela bancal, mais cela devrait fonctionner, en y regardant plus en détails.
14/05/2013, 17h29
FaridM

Ca pourrai marcher, mais comme tu le dis, c'est bancal, je pense qu'il y a plus d'inconvénient que d'avantage à faire comme ça.

Je vais peut-être rester sur une relation ManyToMany, pas l'idéal mais c'est propre.

En tout cas merci de ton aide.
14/05/2013, 17h34
FadeToBlack

De rien, a ton service:ccool:

Un ch'ti RESOLU pour clore le débat..

Bonne semaine
15/05/2013, 20h33
FaridM

Je ne vais pas clore le débat maintenant, peut-être une personne viendra avec une solution.

Salut !

Tu peux faire de l'héritage

Joueur parent de :
-> attaquant
-> defenseur

La doc doctrine : http://docs.doctrine-project.org/en/...le-inheritance

T'aura ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
<?php
namespace MyProject\Joueur;
 
/**
 * @Entity
 * @Table(name="joueurs")
 * @InheritanceType("SINGLE_TABLE")
 * @DiscriminatorColumn(name="discr", type="string")
 * @DiscriminatorMap({"attaquant" = "Attaquant", "defenseur" = "Defenseur"})
 */
class Joueur
{
    /** @Id @Column(type="integer") @generatedValue */
    private $id;
 
    /** @Column(type="string", length=300) */
    private $nom;
 
}

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
 
/**
 * @Entity
 */
class Attaquant extends Joueur
{
   /** @Column(type="integer") */
    private $butsmarques;
 
    /** @OneToMany(targetEntity="Match", inversedBy="id") */
    private $matchs;
 
}
/**
 * @Entity
 */
class Defenseur extends Joueur
{
   /** @Column(type="integer") */
    private $butsencaisses;
 
    /** @OneToMany(targetEntity="Match", inversedBy="id") */
    private $matchs;
}

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
 
/**
 * @Entity
 * @Table(name="matchs")
 */
class Match
{
 
    /** @Id @Column(type="integer") @generatedValue */
    private $id;
 
    /** @Column(length=255, nullable=false) */
    private $nom;
 
 
    /**
     * @ORM\ManyToOne(targetEntity="Attaquant", inversedBy="matchs")
     * @ORM\JoinColumn(name="attaquant_id", referencedColumnName="id")
     */
    private $attaquant;
 
	/**
     * @ORM\ManyToOne(targetEntity="Defenseur", inversedBy="matchs")
     * @ORM\JoinColumn(name="defenseur_id", referencedColumnName="id")
     */
    private $defenseur;
 
}

Après pour le formulaire, vois avec la doc ;)

http://symfony.com/doc/current/cookb...llections.html