IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ SymfonyConsultez toutes les FAQ

Nombre d'auteurs : 17, nombre de questions : 81, dernière mise à jour : 18 juin 2017  Ajouter une question

 

Les questions redondantes se multipliant sur le forum Symfony, nous avons choisi de créer cette FAQ afin de regrouper les questions qui sont posées fréquemment.

Vos remarques et idées sont les bienvenues. Et pourquoi pas votre aide ! S'il vous prend l'envie de tailler votre plus belle plume et de retrousser vos manches, il y a de quoi faire !

SommaireSymfony 2Gestion des bases de données sur Symfony 2Doctrine et Symfony 2 (5)
précédent sommaire suivant
 

Certains types de données, propres à MySQL ne sont pas gérés par Doctrine2 lorsqu'il s'agit de générer le mapping et les entités à partir d'une base existante (reverse engineering).

Néanmoins, il reste la possibilité de facilement les convertir en types basiques. Exemple avec les types ENUM, VARBINARY et TINYBLOB.

Les modifications sont à effectuer dans le fichier app/config.yml, dans la section doctrine (que de la conf, très pratique), voir l'attribut mapping_types :

Code YAML:

Code : Sélectionner tout
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
 
  
# Doctrine Configuration 
doctrine: 
    dbal: 
        default_connection:   default 
        connections: 
            default: 
                driver:   %database_driver% 
                host:     %database_host% 
                port:     %database_port% 
                dbname:   %database_name% 
                user:     %database_user% 
                password: %database_password% 
                charset:  UTF8 
                mapping_types: 
                    enum:       string 
                    varbinary:  string 
                    tinyblob:   text 
            connexion1: 
                ... 
  
    orm: 
        auto_generate_proxy_classes: %kernel.debug% 
        auto_mapping: true

Mis à jour le 14 novembre 2015 Siguillaume

Soit une entité MyEntity (table my_entity), et un champ myEnumField (colonne my_enum_field) faisant référence à un champ de type ENUM MySQL. Ses valeurs acceptables sont 'Value1', 'Value2', 'Value3' :

Code : Sélectionner tout
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
 
<?php 
  
namespace MyCompany\MyBundle\Entity; 
  
use Doctrine\ORM\Mapping as ORM; 
  
/** 
 * MyCompany\MyBundle\Entity\MyEntity 
 */ 
class MyEntity 
{ 
   //ENUM de la colonne my_enum_field 
   const MY_ENUM_FIELD_VALUE1 = 'Value1'; 
   const MY_ENUM_FIELD_VALUE2 = 'Value2'; 
   const MY_ENUM_FIELD_VALUE3 = 'Value3'; 
  
   private $_myEnumFieldValues = array ( 
           self::MY_ENUM_FIELD_VALUE1, self::MY_ENUM_FIELD_VALUE2, self::MY_ENUM_FIELD_VALUE3 
   ); 
  
   /** 
    * @var string $myEnumField 
    */ 
   private $myEnumField; 
  
   /** 
    * Set myEnumField 
    * 
    * @param string $myEnumField 
    */ 
   public function setMyEnumField($myEnumField) 
   { 
      if (!in_array($myEnumField, $this->_myEnumFieldValues)) 
      { 
         throw new \InvalidArgumentException( 
            sprintf('Valeur invalide pour my_entity.my_enum_field : %s.', $myEnumField) 
         ); 
      } 
  
      $this->myEnumField = $myEnumField; 
   } 
  
   /** 
    * Get myEnumField 
    * 
    * @return string 
    */ 
   public function getMyEnumField() 
   { 
      return $this->myEnumField; 
   } 
}

On ne fait plus référence aux valeurs du champ, mais aux constantes, cela permet de centraliser ces valeurs.

Mis à jour le 14 novembre 2015 pc.bertineau Siguillaume

Soit une entité MyEntity (table my_entity), et un champ mySetField (colonne my_set_field) faisant référence à un champ de type SET MySQL. Ses valeurs acceptables sont 'Value1', 'Value2', 'Value3' :

Code : Sélectionner tout
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
 
<?php 
  
namespace MyCompany\MyBundle\Entity; 
  
use Doctrine\ORM\Mapping as ORM; 
  
/** 
 * MyCompany\MyBundle\Entity\MyEntity 
 */ 
class MyEntity 
{ 
   //SET de la colonne my_set_field 
   const MY_SET_FIELD_VALUE1 = 'Value1'; 
   const MY_SET_FIELD_VALUE2 = 'Value2'; 
   const MY_SET_FIELD_VALUE3 = 'Value3'; 
  
   private $_mySetFieldValues = array ( 
           self::MY_SET_FIELD_VALUE1, self::MY_SET_FIELD_VALUE2, self::MY_SET_FIELD_VALUE3 
   ); 
  
   /** 
    * @var array $mySetField 
    */ 
   private $mySetField; 
  
   /** 
    * Set mySetField 
    * 
    * @param array $mySetField 
    */ 
   public function setMySetField(array $mySetField) 
   { 
      foreach ($mySetField as $mySetValue) 
      { 
         if (!in_array($mySetValue, $this->_mySetFieldValues)) 
         { 
            throw new \InvalidArgumentException( 
               sprintf('Valeur invalide pour my_entity.my_set_field : %s.', $mySetValue) 
            ); 
         } 
      } 
  
      $this->mySetField = implode(',', $mySetField); 
   } 
  
   /** 
    * Get mySetField 
    * 
    * @return array 
    */ 
   public function getMySetField() 
   { 
      return explode(',', $this->mySetField); 
   } 
}
On ne fera plus référence aux valeurs du champ, mais aux constantes, cela permet de centraliser.

Mis à jour le 14 novembre 2015 Siguillaume

Le code ci-dessous permet de récupérer les constantes d'une entité, et les afficher dans un formulaire, via une liste déroulante :

Code : Sélectionner tout
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
 
<?php 
  
/** 
*@ORM\Entity 
*@ORM\Table 
*/ 
class User{ 
  
    // Status actif/inactif 
    const S_ENABLED = 1; 
    const S_DISABLED = 0; 
  
    // Status type de paiement 
    const P_CHEQUE = 20; 
    const P_CARTE = 30; 
  
    ... 
    // Le reste de votre entité 
  
  
    /** 
    *  Retourne la liste des status actif et inactif 
    *  Les noms seront en minuscules précédés du nom de l'entité 
    * 
    * @return string 
    */ 
    public static function getListStatus() 
    { 
        $status = array(); 
  
        // On utilisa la classe ReflectionClass pour récupérer nos informations 
        $reflect = new \ReflectionClass(__CLASS__); 
        // On récupère seulement le nom des constantes 
        $constants = array_keys($reflect->getConstants()); 
  
        // Tant qu'il y a des constantes qui débutent par "S_", on les ajoute au tableau 
        foreach ($constants as $const) { 
            if ('S_' == substr($const, 0, 2) ){ 
                // Les clés du tableau seront les valeurs des constantes (1 et 0) 
                // Les valeurs seront les noms des constantes précédés du nom de la classe 
                $status[$reflect->getConstant($const)] = 'user_'.strtolower($const); 
            } 
        } 
        return $status; 
    }     
}
Ce code peut aussi servir pour les traductions. Symfony2 ira chercher automatiquement dans le fichier messages.fr.xliff (ou tout autre fichier de langue) du bundle les clés de traduction correspondant aux noms qui ont été passés.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
<?xml version="1.0"?> 
<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2"> 
    <file source-language="en" datatype="plaintext" original="file.ext"> 
        <body> 
            <trans-unit id="1"> 
                <source>user_s_enabled</source> 
                <target>Utilisateur actif</target> 
            </trans-unit> 
            <trans-unit id="2"> 
                <source>user_s_disabled</source> 
                <target>Utilisateur inactif</target> 
            </trans-unit> 
        </body> 
    </file> 
</xliff>

Mis à jour le 14 novembre 2015 Siguillaume spike2

L'intérêt de la création des classes métier est de séparer la logique métier des actions en y associant des méthodes « raccourci ».

Dans un premier temps, il faut taper la commande qui va générer un dossier Repository contenant des fichiers MonEntityRepository.php. Ce sont ces fichiers qui seront édités pour écrire les requêtes doctrine.

La commande :

php app/console doctrine:generate:entities Acme

L'exemple qui suit porte sur la méthode getPostByBlogId($id) .

Il faut ouvrir le fichier Acme/monBundle/Ressources/config/services.yml en mode édition.

C'est dans ce fichier que seront définies les méthodes « raccourci » permettant de limiter l'écriture de code.

Par exemple pour accéder aux méthodes métier associées aux posts, voici ce qu'il faut écrire :

Code : Sélectionner tout
1
2
3
4
5
6
7
8
 
services: 
  post_repository: 
    factory_service: doctrine.orm.default_entity_manager 
    factory_method: getRepository 
    class: Menu\DemoBundle\Repository\PostRepository 
    arguments: 
             - Menu\DemoBundle\Entity\Post
Le raccourci est créé.

Pour l'utiliser dans une action, il suffit d'écrire la ligne :

Code : Sélectionner tout
$query = $this->get('post_repository')->getPostByBlogId($id);

Mis à jour le 14 novembre 2015 bilbot Siguillaume

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2021 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.