Discussion :

[thor76160]

bonjour,
voilà je viens tout juste d'installer netbeans avec symnfony. c'est la première fois que je fais du php en utilisant un framework, ainsi que de l'objet (en php).
j'aimerais savoir où je pourrais trouver des tuto pour que je sache par quoi commencer.le projet créé comporte une bonne dizaine de dossiers différents, je suis complètement perdu O_o.
j'ai cherché des tuto sur google, malheureusement je ne trouve de l'aide que pour l'installation de symfony, par pour son utilisation :/
help me please ^^

[Michel Rotta]

Le mieux pour commencer est de lire et faire entièrement l'excellent tutoriel JobeetJob proposé par symfony

Ensuite de revenir ici et de discuter du shema.yml (tu verras dans le tuto, on explique ce que c'est) que tu penses mettre en œuvre pour réaliser ton projet.

Après, on pourra commencer à discuter écriture et modules et code...

[belgacem.tlili]

Bonjour ,

voila déjà on a un tutoriel pour configurer netbeans pour utiliser Symfony (depuis la version 6.8),
Netbeans 6.8 et Symfony


pour bien commencer avec Symfony je te recommande d'aller voir la documentation du site officiel et exactement le tutoriel Jobeet qui va vous permet de bien comprendre le concept du framework ainsi une idée plus au moins avancée sur les différents outils utilisée sous le framework

Symfony Project

Jobeet

la documentation est disponible sous plusieurs longues

[thor76160]

merci Michel Rotta pour ton lien, je vais commencer par là ^^

merci aussi à belgacem.tlili, c'est exactement ce tutoriel que j'ai utilisé pour installer Symfony sur netbeans :=)

[thor76160]

je me heurte à un problème. je suis à la page Jour 3 : Le modèle de données.
le tuto propose de créer la base de données à la main, hors moi je préfère la faire avec phpmyadmin et à vrai dire c'est fait depuis longtemps ^^
comment puis-je utiliser Doctrine pour scanner ma base de données et créer les classes comme dans ce tuto svp ?

[bilbonec]

Il s'agit de configurer ton fichier databases.yml pour définir l'accès à ta base de données.

Et ensuite de lancer la commande :

Code :

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

php symfony doctrine:build-schema

qui va te générer ton schema.yml.

CEPENDANT :
Afin de tirer toute la puissance de Doctrine et à fins de meilleures maintenances, je ne peux que te conseiller de faire l'inverse :

• apprendre les principes de fonctionnement du schema.yml : Documentation Doctrine;
• écrire un schema.yml adapté à tes besoins ;
• laisser la gestion de ta base de données à Doctrine, de façon transparente.

Après une petite période d'apprentissage, tu ne pourras que constater l'énorme gain que tu obtiens en passant par la méthode décrite dans ton Jour 3.

[thor76160]

ok, alors j'efface ma base de données et je recommence :/
je croise les doigts pour que je ne fasse aucune erreur ^^
et dans le cas où je peux ajouter une table, un champ ou une relation en plein milieu du projet, ça se fait facilement ?

[bilbonec]

Beaucoup plus facilement que si tu avais à le faire avec phpmyadmin, oui

A chaque fois que tu modifies ton schema.yml, Doctrine va re-générer un ensemble de classes auxquelles tu ne peux pas toucher (Base* dans ton dossier lib) et qui sont tes classes de base pour ajouter tes règles métier.

Donc, si tu ajoutes de nouvelles tables dans le schema.yml, Doctrine va simplement te générer de nouvelles classes auxquelles tu auras accès pour définir de nouvelles règles métier.

Si tu ajoutes des relations, tu auras de nouvelles méthodes dans tes classes de Base*. Idem si tu ajoutes de nouveaux champs.

[thor76160]

Il y a quelque chose d'étrange dans ce tuto !
on ne défini pas soit même la clé primaire de chaque table O_o
j'aimerais que ma table client ait la forme suivante :

Code :

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

1
2
3
id_client int primary key,
nom_client varchar(100) not null,
lien_client varchar(100) not null

en fait je vais utiliser pas mal de jquery, et le fait que plusieurs table aient la même clé primaire appellée "id" va tout chambouler, faut que je rêgle ça !

en fait, voila ma base, je vais faire le .yml et vous me direz si je n'ai fais aucune faute svp ^^

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
 
SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";
 
 
 
 
CREATE TABLE album (
  id_album int(11) NOT NULL AUTO_INCREMENT,
  id_client int(11) NOT NULL,
  nom_album varchar(100) NOT NULL,
  PRIMARY KEY (id_album),
  KEY id_client (id_client)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;
 
 
 
CREATE TABLE `client` (
  id_client int(11) NOT NULL AUTO_INCREMENT,
  nom_client varchar(100) NOT NULL,
  lien_client varchar(100) NOT NULL,
  email_client varchar(100) NOT NULL,
  PRIMARY KEY (id_client)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=7 ;
 
 
 
CREATE TABLE photo (
  id_photo int(11) NOT NULL AUTO_INCREMENT,
  id_position int(11) NOT NULL,
  id_album int(11) NOT NULL,
  url_photo varchar(500) NOT NULL,
  PRIMARY KEY (id_photo),
  KEY id_album (id_album),
  KEY id_position (id_position)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;
 
 
 
CREATE TABLE position (
  id_position int(11) NOT NULL AUTO_INCREMENT,
  nom_position varchar(10) NOT NULL,
  PRIMARY KEY (id_position)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;
 
 
ALTER TABLE `album`
  ADD CONSTRAINT album_ibfk_1 FOREIGN KEY (id_client) REFERENCES `client` (id_client) ON DELETE CASCADE ON UPDATE CASCADE;
 
ALTER TABLE `photo`
  ADD CONSTRAINT photo_ibfk_1 FOREIGN KEY (id_album) REFERENCES album (id_album) ON DELETE CASCADE ON UPDATE CASCADE,
  ADD CONSTRAINT photo_ibfk_2 FOREIGN KEY (id_position) REFERENCES position (id_position) ON DELETE CASCADE ON UPDATE CASCADE;

[thor76160]

voici mon fichier .yml

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
# config/doctrine/schema.yml
eureka_gbClient:
  actAs: { Timestampable: ~ }
  columns:
    nom_client: { type: string(100), notnull: true, unique: true }
    lien_client: { type: string(100), notnull: true, unique: true }
 
eureka_gbAlbum:
  actAs: { Timestampable: ~ }
  columns:
    id_client: { type: integer, notnull: true}
    nom_album: { type: string(100), notnull: true, unique: true }
  relations:
    eureka_gbClient: { onDelete: CASCADE, onUpdate: CASCADE, local: id_client, foreign: id, foreignAlias: eureka_gbAlbum }
 
 
eureka_gbPositon:
  actAs: { Timestampable: ~ }
  columns:
    nom_position: { type: string(10), notnull: true, unique: true }
 
eureka_gbPhoto:
  actAs: { Timestampable: ~ }
  columns:
    id_position: { type: integer, notnull: true}
    id_album: { type: integer, notnull: true}
    url_photo: { type: string(500), notnull: true}
  relations:
    eureka_gbPosition: { onDelete: CASCADE, onUpdate: CASCADE, local: id_position, foreign: id, foreignAlias: eureka_gbPhoto }
    eureka_gbAlbum: { onDelete: CASCADE, onUpdate: CASCADE, local: id_album, foreign: id, foreignAlias: eureka_gbPhoto }

Suis-je obligé d'écrire "eureka_gb" (qui est le nom de mon projet mais aussi de ma base de données) avant chaque nom de table ?

[thor76160]

bon, on va dire que c'est bon.
j'en suis à cette partie :

Code :

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

1
2
$ mysqladmin -uroot -p create jobeet
Enter password: mYsEcret ## The password will echo as ********

je précise que je suis sur windows, alors je dois faire tout ça sans les commandes linux ! comment puis-je m'y prendre ? netbeans peut-il m'aider sur ce coup ?

d'autre part, avec les lignes de commandes vues juste au dessus, je me demande comment il fait pour aller dans le dossier http://localhost/eureka_gb/

[Michel Rotta]

Beaucoup de questions...

Pour ce qui est du l'id unique. Je te recommande fortement d'utiliser systématiquement le nom id en integer primary key pour chaque clef primaire, et autant que possible. Ta vie dans symfony va en être largement simplifiée. Et je n'ai jamais eu de problème avec jQuery à cause de cela. jQuerry n'attaque la base que par un module/action de symfony qui, lui, sait comment récupérer les données.

Ton schéma retouché à ma manière :

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
 
# config/doctrine/schema.yml
 
# sauf si le préfix est réellement utile et constructif, il apporte une lourdeur 
# dans les petites applications et aucun intérêt constructif
# Tous les noms sont en minuscule et au singulier
client:
  actAs: { Timestampable: ~ }
  columns:
    # Il n'est pas nécessaire de mettre nom_client, on est dans la table Client,
    # il est évident que ce n'est pas le nom d'un fournisseur...
    nom: 
      type: string(100)
      notnull: true
      unique: true
    lien:
      type: string(100)
      notnull: true
      unique: true
 
album:
  actAs: { Timestampable: ~ }
  columns:
    # La convention de nommage veut, pour les liens que le nom soit composé
    # <nomDeLaTable>_id
    client_id:
      type: integer
      notnull: true
    nom_album: 
      type: string(100)
      notnull: true
      unique: true
  relations:
    # Le nom de la relation sera utilisé dans les liaisons et les objets du modèle
    # plus il est simple, moins il est compliqué
    # de plus il doit être exactement orthographié comme la classe mise en relation
    # si ce n'est pas réalisable, il faut utilise l'argument "class:"
    client: 
      onDelete: CASCADE
      # onUpdate sur une clef primaire auto incrémentée ? Il y a peu (pas) de chance
      # quel ne soit modifiée
      # Vu que l'on utilise les noms conforme au nommage, il n'est pas nécessaire
      # de les indiquer dans la relation
      foreignAlias: albums
      # Albums est au pluriel, ceci permet d'indiquer que le retour, côté client
      # sera une collection d'albums. En minuscule toujours 
 
positon:
  actAs: { Timestampable: ~ }
  columns:
    nom_position: 
      type: string(10)
      notnull: true
      unique: true
 
photo:
  actAs: { Timestampable: ~ }
  columns:
    position_id:
      type: integer
      notnull: true
    album_id:
      type: integer
      notnull: true}
    url_photo:
      type: string(500)
      notnull: true
  relations:
    Position:
      onDelete: CASCADE
      foreignAlias: photos
    album:
      onDelete: CASCADE
      foreignAlias: photos

L'écriture du yaml avec des {} est parfaite, je la trouve juste moins lisible.
Ce schéma devrait être plus lisible et générer un modèle plus simple à mettre en œuvre avec Doctrine.

[thor76160]

merci pour cette réponse. un petit détail me chagrine cependant, la clé primaire de la table "photo" est composée de id et de position_id, c'est donc un identifiant relatif. est-il possible de faire une telle clé primaire avec symfony ?

je cherche tjr un tutoriel pour symfony sur windows, mais ça manque un peu sur le net O_o
je n'arrive toujours pas à réaliser les parties "La base de données" et "L'ORM" de ce tutoriel http://www.symfony-project.org/jobee...Doctrine/fr/03.

[thor76160]

je propose la modification suivante :

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
photo:
  actAs: { Timestampable: ~ }
  columns:
    position_id:
      type: integer
      primaryKey: true
      notnull: true
    album_id:
      type: integer
      notnull: true}
    url_photo:
      type: string(500)
      notnull: true
  relations:
    Position:
      onDelete: CASCADE
      foreignAlias: photos
    album:
      onDelete: CASCADE
      foreignAlias: photos

à savoir

Code :

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

primaryKey: true

sur le champ position_id.
est-ce correct ?

[Michel Rotta]

Je ne pense pas que cela soit une bonne idée.

En effet, avec ta modification le champ position_id devient la clef primaire de ta table. Il n'y aura pas de création automatique d'un champ Id. Tu ne pourras avoir qu'une photo par position.

Je ne pense pas que cela soit ce que tu souhaites.

Pourquoi vouloir intégrer position_id dans la clef ?

[thor76160]

bon voilà, à vrai dire c'est pour des photos de chantier, pour une entreprise de plafonnage. on a les position "avant" et "après". pour la photo n°17, il y aura la version avant et la version après. elles ont donc le même id pour dire qu'elles sont de paire ! donc on a une photo d'un bâtiment ou d'une pièce avant et après le chantier.

avant = 1
après = 2

photo n°17 - avant : id = 17, position_id = 1
photo n°17 - après : id = 17, position_id = 2

j'aimerais retranscrire cette méthodologie qui est à la fois simple et compréhensible ... j'espère que c'est possible

une proposition :

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
photo:
  actAs: { Timestampable: ~ }
  columns:
    id:
      type: integer
      primary: true
      notnull: true
    position_id:
      type: integer
      primary: true
      notnull: true
    album_id:
      type: integer
      notnull: true}
    url_photo:
      type: string(500)
      notnull: true
  relations:
    position:
      onDelete: CASCADE
      foreignAlias: photos
    album:
      onDelete: CASCADE
      foreignAlias: photos

[Michel Rotta]

OK, donc, en fait, ton champ position ne peut être que avant ou après ?

Je ne pense pas que cela soit une bonne idée.

Je vois trois solution :

1. dans la table photo, on met deux photos, une avant, une après par enregistrement, la table position vire.
2. dans la table album on met deux champs photo, un photo_avant_id et un photo_apres_id, la table position vire, on refait les relations.
3. on garde la structure actuel qui rempli bien (niveau MLD) les contraintes, pas de clef primaire sur position_id, on peut envisager un index supplémentaire et unique sur id et position_id pour s'assurer qu'il n'y ait pas deux photos avant (mais est-ce une bonne idée). En effet, on pourrait avoir des demandes pour avoir, un jour, en extension de l'application, des photos pendant, ou plusieurs avant...

Mon idée ? dans l'ordre 3-2-1 Mais il est possible que la 2, plus limitée, soit aussi plus simple à coder et à utiliser, ce qui sont des contraintes que je peux comprendre.

[thor76160]

j'accepte le principe de ta première solution !! je n'y avais même pas pensé, quel boulet je suis !! lol
à propos, j'ai trouvé le moyen de lancer des lignes de commandes linux sur windows ! netbeans le propose avec "run commands" alors mon projet peut avancer de nouveau !
bon, j'ai commencé le Jour 4 du tutoriel de symfony-project. mais je me rend compte d'une chose flipante ... ya qu'un seul dossier web O_o comment je fais pour différencier mon front-office et mon back-office ? car j'admets que je vais commencer par mon back-office !

[bilbonec]

Je n'ai lu que rapidement tous les posts mais :
- normalement tu es censé pouvoir lancer toutes les commandes avec la console Windows (Exécuter > "cmd"). Ceci dit, tu as trouvé une solution alternative
(par contre, je n'arrive pas à avoir la coloration syntaxique dedans ...)
- lorsque tu créeras différentes applications dans ton projet avec la commande (qui correspondent à différents dossiers dans apps) :

Code :

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

./symfony generate:app

Symfony te rajoutera un contrôleur dans web, du type :

frontend_dev.php

où :
- frontend, correspond au nom de ton application ;
- dev, à ton environnement de développement (autres : prod et test).

Donc, si tu as un frontoffice et un backoffice, dans ton dossier web tu auras :
- frontend_dev.php ;
- backend_dev.php.
Reste juste à bien configurer Apache en fonction de ce que tu veux voir apparaître dans ta barre d'adresse !

[thor76160]

en effet j'ai bien 2 fichiers backend_dev.php et frontend_dev.php, apparemment ils sont automatiquement créé avec netbeans. je vais voir comment les utiliser.
sur ce, je vais continuer le tutoriel ^^

merci !

EDIT:
la découverte des modules créés automatiquement. ben je crois que je vais les faire moi-même ^^