Discussion :

[blasil64]

Bonsoir à tous,
Voici mon site Internet. Comme vous pouvez le constater, il me permet de faire suivre aux internautes les actualités du cinéma et des sorties DVD. J'y insère aussi mon avis sur les films que je regarde afin de pouvoir aider l'internaute dans son choix s'il désire regarder un film par exemple.
Je souhaiterais élargir mon site pour permettre aux internautes de s'inscrire sur mon site, afin d'y laisser leurs avis sur les films qu'ils regardent eux aussi. Pour cela, j'aimerais refaire mon site sous symfony afin d'y intégrer un backend et une gestion des utilisateurs. Je repars donc de zéro en commençant par la base de données. C'est pour cela que je viens vous voir afin de valider ma base pour commencer plus tard le code.
Je rajoute que je suis novice sous symfony, j'ai débuté en décembre dans une entreprise et je travailler dessus 2 jours par semaine.

Voici mon schéma que j'ai créé : ici

et voici le schéma.yml qui en découle :

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
films:
  actAs: { Timestampable: ~ }
  columns:
    id_films:              { type: integer, notnull: true, unique: true }
    titre:                 { type: string(255) }
    affiche:               { type: string(255) }
    date_sortie_cinema:    { type: string(25) }
    date_sortie_dvd:       { type: string(25) }
    date_sortie_cinema_1:  { type: date }
    date_sortie_dvd_1:     { type: date }
    date_avis:             { type: datetime }
    date_jaquette:         { type: date }
    realisateur:           { type: string(65) }
    acteurs:               { type: string(255) }
    genre:                 { type: string(255) }
    duree:                 { type: string(10) }
    resume:                { type: string(2555) }
    avis:                  { type: string(2555) }
    video:                 { type: string(255) }
    titre_secret:          { type: string(255) }
    secret:                { type: string(2555) }
    bonus_dvd:             { type: string(2555) }
    bonus_bluray:          { type: string(2555) }
    jaquette:              { type: string(255) }
  relations:
    avis_utilisateurs:
      class: avis_utilisateurs
      refClass: films
      local: id_films
      foreign: id_avis_utilisateurs
      foreignAlias: avis
 
avis_utilisateurs:
  actAs: { Timestampable: ~ }
  columns:
    id_avis_utilisateurs:   { type: integer, notnull: true, unique: true }
    date_avis:              { type: string(25)}
    date_avis_1:            { type: date, notnull: true }
    avis:                   { type: string(2555), notnull: true }
    is_active:              { type: boolean, notnull: true, default: 0 }
  relations:
    utilisateurs:
      class: utilisateurs
      refClass: avis
      local: id_avis
      foreign: id_utilisateurs
      foreignAlias: utilisateurs
 
utilisateurs:
  actAs: { Timestampable: ~ }
  columns:
    id_utilisateurs: { type: integer, notnull: true, unique: true }
    nom:             { type: string(100), notnull: true }
    prenom:          { type: string(100), notnull: true }
    date_naissance:  { type: date }
    pseudo:          { type: string(40), notnull: true }
    mot_de_passe:    { type: string(50), notnull: true }
    email:           { type: string(100), notnull: true }
    is_super_admin:  { type: boolean, notnull: true, default: 0 }
    is_active:       { type: boolean, notnull: true, default: 0 }

Si je vous le donne, c'est pour que vous puissiez le critiquer et que je puisse l'améliorer. Je vais vous l'expliquer.
Pour la table films :
- Alors bon un id pour qu'il y ait un id par film qui s'autoincrémente
- Son titre
- L'affiche (hébergé, donc des caractères)
- date_sortie_cinema pour écrire la date en tout lettre (17 janvier 2010)
- De même pour la date de sortie en dvd
- date_sortie_cinema_1 pour la format date afin que dans les requêtes je puisse faire un tri par rapport à la date.
- Idem pour la date de sortie en dvd
- La date de mon avis avec l'heure, il peut arriver que je mette deux avis par jour...
- Réalisateur, acteurs, genre, duree, resume, avis => des caractères
- La vidéo, je récupère un lien youtube, si je créé mon lecteur vidéo (ce que j'aimerais ), cela pourrait évoluer...
- Un secret du tournage avec son titre
- Les bonus dvd et bluray qui peuvent être long...
- La jaquette hébergé sur hosting, je dois donc insérer une url pour l'afficher.
- Cette table est liéé avec la table avis_utilisateurs, car sur la page d'un film, les utilisateurs inscrits et connectés pourront ajouter leur avis sur le film.

La table avis_utilisateurs :
- Son id
- La date en toute lettre comme pour le film pour l'afficher
- La date en date pour faire un tri
- L'avis de l'internaute
- Si l'avis est actif pour que je puisse controler que l'avis ne soit pas n'importe quoi quand même.
- Cette table est liée avec la table utilisateurs car les utilisateurs mettents des avis.

La table utilisateurs
- son id
- Un nom, prénom, date de naissance, pseudo mot de passe et email de contact.
- si il est admin ou pas, normalement il n'y aurait que moi
- Si le membre est actif ou pas, si je décide de le supprimer en cas de non respect des règles...


Voilà un gros tour d'horizon, donc n'hésitez pas à critiquer, c'est la première fois sous symfony pour le fichier schema.yml. Ensuite, je pense à mes différents champs date qui pourrait se simplifier grâce à des fonctions ou quoi, s'il y a des champs qui seraient plus utiles, ou par rapport à mes relations parce que là j'en ai aucune idée de comment cela s'écrivait.

Sur ce, merci d'avance pour vos réponses !

[noreaga10]

Bonjour,

Je vais essayer d'améliorer ce schema (modestement).

Premièrement, tu peux supprimer tout les id (id_films, id_avis_utilisateurs et id_utilisateurs). Ils se créeront tout seul (en tout cas avec Doctrine).

Ensuite, concernant les types de relations, je pense que tu fais erreur.

Utilisateur->Avis_utilisateurs : type 1-n, je pense qu'un utilisateur peut émettre plusieurs avis, mais un avis n'appartient qu'à un utilisateur.

De même,
Film->Avis_utilisateurs : type 1-n, un film est lié à plusieurs avis, mais un avis n'est lié qu'à un seul film (ça semblerait plus logique, à moins que tu donnes le même avis sur plusieurs films).

Et il n'est pas nécessaire d'écrire les relations des deux côtés.

Enfin, je ne comprend pas le champs avis dans la table Films.
Parce que si tu souhaites mettre plusieurs avis pour jour, soit tu te comporte comme un membre lambda (et là tu peux ajouter tes avis comme tout le monde, ca pourrait ressortir d'une autre couleur par exemple, en checkant si tu as le statut super-admin), soit tu crée une autre table genre 'Avis_admin'.
Je serai toi je laisserai ce champs avis, qui te permet d'entrer une opinion général, et si tu veux ajouter d'autres avis pour échanger avec tes membres je me logguerai en tant que membre avec statut super-admin.

Ce qui donne:

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
 
Film:
  actAs: { Timestampable: ~ }
  columns:
    titre:                 { type: string(255) }
    affiche:               { type: string(255) }
    date_sortie_cinema:    { type: string(25) }
    date_sortie_dvd:       { type: string(25) }
    date_sortie_cinema_1:  { type: date }
    date_sortie_dvd_1:     { type: date }
    date_avis:             { type: datetime } <--- pas sûr que ça soit utile puisque ça correspondra au created_at
    date_jaquette:         { type: date }
    realisateur:           { type: string(65) }
    acteurs:               { type: string(255) }
    genre:                 { type: string(255) }
    duree:                 { type: string(10) }
    resume:                { type: string(2555) }
    avis:                  { type: string(2555) }
    video:                 { type: string(255) }
    titre_secret:          { type: string(255) }
    secret:                { type: string(2555) }
    bonus_dvd:             { type: string(2555) }
    bonus_bluray:          { type: string(2555) }
    jaquette:              { type: string(255) }
 
Avis_utilisateurs:
  actAs: { Timestampable: ~ }
  columns:
    utilisateur_id:     { type: integer, notnull: true }
    film_id :            { type: integer, notnull: true }
    date_avis:          { type: date, notnull: true } <-- pas la peine avec le actAs
    avis:                  { type: string(2555), notnull: true }
    is_active:            { type: boolean, notnull: true, default: 0 }
  relations:
    Utilisateur:    { local: utilisateur_id, foreign: id, foreignAlias: Avis }
    Film:            { local: film_id, foreign: id, foreignAlias: Avis }
 
Utilisateur:
  actAs: { Timestampable: ~ }
  columns:
    nom:             { type: string(100), notnull: true }
    prenom:          { type: string(100), notnull: true }
    date_naissance:  { type: date }
    pseudo:          { type: string(40), notnull: true }
    mot_de_passe:    { type: string(50), notnull: true }
    email:           { type: string(100), notnull: true }
    is_super_admin:  { type: boolean, notnull: true, default: 0 }
    is_active:       { type: boolean, notnull: true, default: 0 }

[blasil64]

Bonjour,
Tout d'abord, merci pour ta réponse.
Alors, je vais bien dvelopper sous doctrine, donc j'enlève les id.
Ok pour mes relations, c'est ce que je voulais faire à la base.

Enfin, je ne comprend pas le champs avis dans la table Films.
Parce que si tu souhaites mettre plusieurs avis pour jour, soit tu te comporte comme un membre lambda (et là tu peux ajouter tes avis comme tout le monde, ca pourrait ressortir d'une autre couleur par exemple, en checkant si tu as le statut super-admin), soit tu crée une autre table genre 'Avis_admin'.
Je serai toi je laisserai ce champs avis, qui te permet d'entrer une opinion général, et si tu veux ajouter d'autres avis pour échanger avec tes membres je me logguerai en tant que membre avec statut super-admin.

Concernant le champ avis, je n'avais pas pensé à pouvoir écrire mon avis en me connectant et pourquoi pas en mettant mon avis en couleur ou en le mettant en premier. Par contre, du coup, j'enlèverai le champ avis dans la table films, parce que mettre une opinion générale pourrait s'avérer difficile, vu qu'on n'a pas tous les mêmes goûts, et mettre une opinion générale sur un film où l'on écrit, j'ai adoré et un autre j'ai détesté risque d'être difficile. Du coup, date_avis dans la table film pourrait être supprimé.

Que signifie le actAs alors ? Car tu me dis que je ne suis pas obligé de mettre date_avis dans la table avis_utilisateurs...

Merci d'avance pour les réponses !

[noreaga10]

En écrivant:
actAs: { Timestampable: ~ }

Doctrine te créera automatiquement deux champs (type timestamp):
- un champs 'created_at' qui enregistrera automatiquement la date de création de l'avis
- et un champs 'updated_at', qui enregistre la date en cas d'update de l'avis

Donc la date de création d'un avis sera enregistré dans le champs 'created_at'.

[blasil64]

Ok ok, alors je vais supprimer le champ avis de la table film et ce sera géré comme un utilisateur normal pour mon avis mais en couleur différente ou toujours en tête des avis, à voir plus tard.

Du coup mon schema.yml ressemble à cela :

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
Film:
  actAs: { Timestampable: ~ }
  columns:
    titre:                 { type: string(255) }
    affiche:               { type: string(255) }
    date_sortie_cinema:    { type: string(25) }
    date_sortie_dvd:       { type: string(25) }
    date_sortie_cinema_1:  { type: date }
    date_sortie_dvd_1:     { type: date }
    date_jaquette:         { type: date }
    realisateur:           { type: string(65) }
    acteurs:               { type: string(255) }
    genre:                 { type: string(255) }
    duree:                 { type: string(10) }
    resume:                { type: string(2555) }
    video:                 { type: string(255) }
    titre_secret:          { type: string(255) }
    secret:                { type: string(2555) }
    bonus_dvd:             { type: string(2555) }
    bonus_bluray:          { type: string(2555) }
    jaquette:              { type: string(255) }
 
Avis_utilisateurs:
  actAs: { Timestampable: ~ }
  columns:
    utilisateur_id:     { type: integer, notnull: true }
    film_id :            { type: integer, notnull: true }
    avis:                  { type: string(2555), notnull: true }
    is_active:            { type: boolean, notnull: true, default: 0 }
  relations:
    Utilisateur:    { local: utilisateur_id, foreign: id, foreignAlias: Avis }
    Film:            { local: film_id, foreign: id, foreignAlias: Avis }
 
Utilisateur:
  actAs: { Timestampable: ~ }
  columns:
    nom:             { type: string(100), notnull: true }
    prenom:          { type: string(100), notnull: true }
    date_naissance:  { type: date }
    pseudo:          { type: string(40), notnull: true }
    mot_de_passe:    { type: string(50), notnull: true }
    email:           { type: string(100), notnull: true }
    is_super_admin:  { type: boolean, notnull: true, default: 0 }
    is_active:       { type: boolean, notnull: true, default: 0 }

Ne faut-il pas ajouter les created_at et updated_at ?
Y a-t-il autre chose que Timestampable ?

Merci encore de tes réponses !

[Michel Rotta]

Je vais jeter mon grain de sel.

Pour les tables, évite les tables du type nom_suite, c'est générateur de problèmes, avis_utilisateur pourrait parfaitement être : avis.

Bon il est plus simple aussi d'éviter les 's' à la fin du nom d'une table

Pour les nom des champs lié il vaut mieux mettre <nomtable>_id, c'est le format supposé par doctrine et il peut créer la relation bien plus simplement.

Si tu ne défini pas de champ primaire sur une table, doctrine le rajoute comme l'a dit Noreage, ce champ est de type integer(8), il faut le préciser pour les champs liés. Pense a indexé les champs liés.

Tu vas te prendre la tête a gérer les utilisateurs, administration, création, modification, mail de contrôle, contrôle du mail de contrôle, fenêtre de login, cryptage du passe, gestion des oublis de passe, gestion des droits,... Il y a un plugin qui gère tous cela c'est sfGuardPlugin, un peu d'apprentissage en plus mais un sacré gain de temps à l'arrivé (bon, ok surtout à partir de la troisième application).