Discussion :

[jekif]

Bonjour,

Je suis tout nouveau sur symfony et doctrine. Je suis en train de me former en fait sur un mini projet perso de gestion de factures et de devis...

Je rencontre en ce moment un problème au chargement des données de test, au moment de la configuration du projet. Quand je fais :

Code :

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

$ php symfony doctrine:build --all --and-load

j'obtiens le message d'erreur suivant :

SQLSTATE[23000]: Integrity constraint violation: 1452 Cannot add or update a child row: a foreign key constraint fails (`smith`.`facture`, CONSTRAINT `facture_client_id_client_id` FOREIGN KEY (`client_id`) REFERENCES `client` (`id`))

Comme je ne suis pas spécialiste de SQL, j'avoue avoir un peu de difficulté à comprendre ce message. Mais la valeur de CONSTRAINT me semble étrange. Et en bref ça bloque, les données ne sont pas insérées...

Je ne sais pas si le schema.yml peut être en cause alors je le copie ci-dessous :

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
Client:
 actAs: { Timestampable: ~ }
 columns:
  nom: { type: string(255), notnull: true }
  adresse1: { type: string(255), notnull: true }
  adresse2: { type: string(255) }
  cp: { type: string(255), notnull: true }
  ville: { type: string(255), notnull: true }
  pays: { type: string(255), notnull: true, default: "France" }
  siret: { type: string(155) }
 
Contact:
 actAs: { Timestampable: ~ }
 columns:
  civilite:
   type: enum
   length: 3
   values: ['M.','Mme','Melle']
  nom: { type: string(255), notnull: true }
  prenom: { type: string(255), notnull: true }
  fonction: { type: string(255) }
  tel: { type: string(255) }
  gsm: { type: string(255) }
  fax: { type: string(255) }
  courriel: { type: string(255) }
  client_id: { type: integer, notnull: true }
 relations:
  Client: { local: client_id, foreign: id, foreignAlias: Clients }
 
Facture:
 actAs: { Timestampable: ~ }
 columns:
  numero: { type: integer, notnull: true }
  prestation: { type: string(255), notnull: true }
  client_id: { type: integer, notnull: true }
  echeance: { type: date, notnull: true }
  devis: { type: boolean, notnull: true, default: true }
  payee: { type: date }
 relations:
  Client: { local: client_id, foreign: id, foreignAlias: Factures }
 
EntreeFacture:
 actAs: { Timestampable: ~ }
 columns:
  facture_id: { type: integer, notnull: true }
  designation: { type: string(255), notnull: true }
  montant_ht:
   type: decimal(6)
   scale: 2
 relations:
  Facture: { local: facture_id, foreign: id, foreignAlias: Entrees }

Merci d'avance pour votre aide

[Herode]

A priori, tu essayes d'ajouter une facture liée à un client qui n'existe pas. On peut voir ton jeu de test (fixtures.yml sans doute) ?

[jekif]

En fait j'ai inversé les valeurs foreign et id pour chacune des relations, et l'insertion des données à fonctionner.

Par contre, ensuite, ce sont mes modèles qui ne fonctionnaient plus. Je les ai donc regénérés sans charger les données.

Ceci dit, lors de l'import des données, les relations entre tables ne se sont pas faites correctement et j'ai dû retoquer ça manuellement...

[jekif]

Et même maintenant, en essayant un

Code :

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

$this->embedRelation("EntreeFacture");

dans FactureForm.class.php, je vois que les relations entre tables n'existent pas.

stack trace

* at ()
in SF_ROOT_DIR/lib/vendor/symfony/lib/plugins/sfDoctrinePlugin/lib/vendor/doctrine/Doctrine/Relation/Parser.php line 237 ...
234.
235. return $this->getRelation($alias, false);
236. } else {
237. throw new Doctrine_Table_Exception('Unknown relation alias ' . $alias);
238. }
239. }

Je dois donc avoir un problème dans mon schema.yml. Je le reposte ci-dessous, vu que j'ai essayé quelques modifications :

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
Client:
 actAs: { Timestampable: ~ }
 columns:
  nom: { type: string(255), notnull: true }
  adresse1: { type: string(255), notnull: true }
  adresse2: { type: string(255) }
  cp: { type: string(255), notnull: true }
  ville: { type: string(255), notnull: true }
  pays: { type: string(255), notnull: true, default: "France" }
  siret: { type: string(155) }
 
Contact:
 actAs: { Timestampable: ~ }
 columns:
  civilite:
   type: enum
   length: 3
   values: ['M.','Mme','Melle']
  nom: { type: string(255), notnull: true }
  prenom: { type: string(255), notnull: true }
  fonction: { type: string(255) }
  tel: { type: string(255) }
  gsm: { type: string(255) }
  fax: { type: string(255) }
  courriel: { type: string(255) }
  client_id: { type: integer, notnull: true }
 relations:
  Client:
   foreignType: one
   local: client_id
   foreign: id
 
Facture:
 actAs: { Timestampable: ~ }
 columns:
  numero: { type: integer, notnull: true }
  prestation: { type: string(255), notnull: true }
  client_id: { type: integer, notnull: true }
  echeance: { type: date, notnull: true }
  devis: { type: boolean, notnull: true, default: true }
  payee: { type: date }
 relations:
  Client:
    foreignType: one
    local: client_id
    foreign: id
 
EntreeFacture:
 actAs: { Timestampable: ~ }
 columns:
  facture_id: { type: integer, notnull: true }
  designation: { type: string(255), notnull: true }
  montant_ht:
   type: decimal(6)
   scale: 2
 relations:
  Facture:
   foreignAlias: Entrees
   local: facture_id
   foreign: id

Pour les relations :
client 1 <-> 1 contact
facture n <-> 1 client
facture 1 <-> n EntreeFacture

Voilà, je ne suis pas à l'aise avec le yml, mais il va bien falloir que je comprenne le fonctionnement. j'ai beau chercher sur la toile, les essais que je fais sont infructueux.

Merci d'avance

[Herode]

Avec ce schéma, le modèle Facture connaît deux relations

- Client, qui est directement déclarée dans ton modèle Facture :

Code :

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

1
2
3
4
5
6
7
8
Facture:
 columns:
    ...
 relations:
  Client:
    foreignType: one
    local: client_id
    foreign: id

- Entrees, qui est déclarée dans le modèle EntreeFacture:

Code :

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

1
2
3
4
5
6
7
8
EntreeFacture: 
 columns:
    ...
 relations:
  Facture:
   foreignAlias: Entrees
   local: facture_id
   foreign: id

En plus, la cardinalité est mal déclarée et Client ne peut avoir qu'une seule Facture, ce qui n'est sans doute pas ce que tu désires.

Le mode d'emploi des fichiers .yml pour les schémas se trouve sur le site de Doctrine, en particulier ici :
http://www.doctrine-project.org/proj...l-schema-files

Pas toujours très clair, c'est vrai, mais heureusement la construction est logique et on finit par s'y faire. En résumé et sauf erreur de ma part, pour traiter les relations les règles minimales à retenir pour se simplifier la vie sont :
- par défaut, une relation pointe la colonne table_distante_id sur la table locale
- par défaut, une relation pointe la colonne id sur la table distante
- il est préférable de déclarer la relation dans la table où se trouve la clé étrangère
- par défaut la relation est donc de type: one foreignType: many.

Pour la structure que tu cites :
client 1 <-> 1 contact
facture n <-> 1 client
facture 1 <-> n EntreeFacture

pour aller au plus simple, je ferai quelque chose du style

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
 
Client: 
  columns: 
    # colonnes du client + colonnes du contact puisqu'on est en 1-1
 
Facture:
  columns: 
    #...
  relations:
    Client: # nom de la relation dans la classe Facture  + pointe sur la table Client
      foreignAlias: Factures # nom de la relation dans la classe Client         
      onDelete: restrict # ou autre selon ton architecture
 
EntreeFacture: 
  columns: 
    # ...
  relations:
    Facture: # nom de la classe pointée
      alias: MaFacture # inutile ici, c'est juste un exemple si tu voulais renommer la relation : la relation s'appellerait alors MaFacture au lieu de s'appeler (par défaut) Facture 
      foreignAlias: EntreeFacture
      onDelete: cascade

(non testé, mais à une ou deux coquilles près ça devrait marcher)

NB : par exemple pour le modèle EntreeFacture ci-dessus, si on ajoute les champs avec les valeurs par défaut et les alias fantaisistes en moins, tu aurais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
EntreeFacture: 
  columns: 
    # ...
  relations:
    Facture: 
      local: facture_id
      foreign: id
      type: one
      foreignType: many
      foreignAlias: EntreeFacture
      onDelete: cascade

avec :
- type: one -> génère des accesseurs get/setFacture() dans la classe EntreeFactureBase tels que get...() prend un Doctrine_Record en argument et set...() renvoie un Doctrine_Record, donc 1 objet : une EntreeFacture est associée à une Facture et une seule
- foreignType: many -> génère des accesseurs get/setEntreesFacture() dans la classe FactureBase tels que get...() prend un Doctrine_Collection en argument et set...() renvoie un Doctrine_Collection, donc plusieurs objets : une Facture a une ou plusieurs EntreeFacture.

[jekif]

@ Herode : je te remercie pour ton explication plutôt détaillée.

Je ne sais pas si j'ai bien tout compris, mais j'ai apporté les modifications que tu m'as préconisées. Par contre, je laisse contact et client séparés des fois qu'un jour j'ai besoin de plusieurs contacts pour un même client.

Ceci dit, y-t-il un moyen de tester si cette structure relationnelle est correcte ? En effet j'ai toujours un problème avec embedRelation()... Je ne sais pas s'il y a un rapport avec cette structure.

A ce sujet j'ai ouvert un nouveau post : http://www.developpez.net/forums/d10...n/#post5647765

Je sens que ce sont les problèmes du débutant qui débarque dans symfony et qui n'y a pas ses repères habituels....