Symfony2 Sonata Admin Bundle

Symfony2 Sonata Admin Bundle
Ensemble Sonata Admin

Dans cette publication, vous pourrez travailler avec Sonata Admin Bundle. Suivez simplement l'étape ci-dessous et à la fin de cette publication, vous obtiendrez un fonctionnement fonctionnel complet avec ce paquet.
Pour utiliser Sonata Admin Bundle, vous devez installer et configurer le cadre Symfony2. J'espère que vous êtes prêts à le faire.

Installation

1.1.    Téléchargement de la morue

Utilisez le compositeur pour gérer vos dépendances et télécharger SonataAdminBundle:

>php composer.phar nécessite sonata-project / admin-bundle

Vous devrez taper une contrainte de version. 'Dev-master' vous procurera la dernière version, compatible avec la dernière version de Symfony2. Vérifiez le packagist pour les anciennes versions:

Fournissez une contrainte de version pour l'exigence sonata-project / admin-bundle: dev-master

1.2.    Téléchargement d'un paquet de stockage

SonataAdminBundle peut fonctionner avec plusieurs mécanismes de stockage. Nous utilisons Doctrine ORM afin d'installer SonataDoctrineORMAdminBundle.

>compositeur nécessite sonata-project / doctrine-orm-admin-bundle

Vous devrez taper une contrainte de version. «Dev-master» vous obtiendra généralement la version la plus récente et la plus sautante. Vérifiez le packagist pour les versions stables et anciennes:
Fournissez une contrainte de version pour le projet sonate /

doctrine-orm-admin-bundle requis: dev-master

1.3.    Activation de SonataAdminBundle et de ses dépendances

SonataAdminBundle s'appuie sur d'autres paquets pour implémenter certaines fonctionnalités. En plus de la couche de stockage mentionnée à l'étape 2, il existe d'autres faisceaux nécessaires pour que SonataAdminBundle fonctionne:

  • SonataBlockBundle
  • SonatajQueryBundle
  • KnpMenuBundle (Version 1.1.*)

Ces paquets sont automatiquement téléchargés par le compositeur comme une dépendance de SonataAdminBundle. Toutefois, vous devez les activer dans votre AppKernel.php et les configurer manuellement. N'oubliez pas d'activer SonataAdminBundle aussi:

// app/AppKernel.php
public function registerBundles()
{
       return array(
        // ...

        // Ajoutez vos dépendances
        new Sonata\BlockBundle\SonataBlockBundle(),
        new Sonata\jQueryBundle\SonatajQueryBundle(),
        new Knp\Bundle\MenuBundle\KnpMenuBundle(),
        new Sonata\DoctrineORMAdminBundle\SonataDoctrineORMAdminBundle(),

        // Ensuite, ajoutez SonataAdminBundle
        new Sonata\AdminBundle\SonataAdminBundle(),
        // ...
        );
}

1.4.    Configuration des dépendances SonataAdminBundle

SonataAdminBundle fournit un bloc SonataBlockBundle utilisé dans le tableau de bord de l'administration. Pour pouvoir l'utiliser, assurez-vous qu'il est activé sur la configuration de SonataBlockBundle:

YAML

# app/config/config.yml
sonata_block:
        default_contexts: [cms]
        blocks:
        # Activer le bloc SonataAdminBundle
        sonata.admin.block.admin_list:
                contexts: [admin]
        # Vos autres blocs

1.5.    Nettoyer

Maintenant, installez les actifs à partir des paquets:

php app / console assets: installer le Web

Habituellement, lors de l'installation de nouveaux paquets, il est recommandé de supprimer également votre cache:

cache php application / console: clear
Mise en route de SonataAdminBundle

Si vous avez suivi les instructions d'installation, SonataAdminBundle devrait être installé mais inaccessible. Vous devez d'abord la configurer pour vos modèles avant de pouvoir l'utiliser. Voici une liste de contrôle rapide de ce qui est nécessaire pour configurer rapidement SonataAdminBundle et créer votre première interface d'administration pour les modèles de votre application:

  • Étape 1: définir les itinéraires SonataAdminBundle
  • Étape 2: Créer une classe Admin
  • Étape 3: Créer un service d'administration
  • Étape 4: Configuration

Étape 1: définir les itinéraires SonataAdminBundle

Pour pouvoir accéder aux pages de SonataAdminBundle, vous devez ajouter ses itinéraires au fichier de routage de votre application:
YAML

# app/config/routing.yml
admin:

        resource:@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
        prefix: /admin

_sonata_admin:
        resource: .
            type: sonata_admin
            prefix: /admin

À ce stade, vous pouvez déjà accéder au tableau de bord vide (vide) en visitant l'url: http://yoursite.local/admin/dashboard.

Étape 2: Créer une classe Admin

SonataAdminBundle vous aide à gérer vos données en utilisant une interface graphique qui vous permettra de créer, mettre à jour ou rechercher les instances de votre modèle. Ces actions doivent être configurées, ce qui se fait à l'aide d'une classe Admin.
Une classe Admin représente le mappage de votre modèle à chaque action de l'administration. Dans celui-ci, vous décidez sur les champs à afficher sur une liste, à utiliser comme filtres ou à afficher sur un formulaire de création / édition.
Le moyen le plus simple de créer une classe Admin pour votre modèle est d'étendre la classe Sonata \ AdminBundle \ Admin \ Admin.
Supposons que votre JigarUserBundle possède une entité utilisateur. Voici comment une classe d'administration de base pourrait ressembler à:

namespace Jigar\UserBundle\Admin;

use Sonata\AdminBundle\Admin\Admin;
use Sonata\AdminBundle\Datagrid\ListMapper;
use Sonata\AdminBundle\Datagrid\DatagridMapper;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\AdminBundle\Show\ShowMapper;
class UserAdmin extends Admin {

protected function configureFormFields(FormMapper $formMapper)
{
   $formMapper
      ->add('username', 'text', array('label' => 'User Name'))
      ->add('firstname')
      ->add('lastname')
      ->add('email')
      ->add('password');
}

protected function configureDatagridFilters(DatagridMapper $datagridMapper)
{
   $datagridMapper->add('username', null, array('label' => 'User Name')
      ->add('email');
}

protected function configureListFields(ListMapper $listMapper)
{
   $listMapper
      ->addIdentifier('username')
      ->add('email')
      ->addIdentifier('enabled', null, array('template' =>
         'JigarUserBundle:CRUD:status_field.html.twig'))
      ->addIdentifier('roles', null, array(
         'template' => 'JigarUserBundle:CRUD:list_roles.html.twig',
      ))
      ->add('phone')
      ->add('_action', 'actions', array(
         'actions' => array(
         'show' => array(),
         'edit' => array(),
         'delete' => array()
      )
      ));
}
protected function configureShowField(ShowMapper $showMapper)
{
   $showMapper
      ->add('username')
      ->add('email');
}

Étape 3: Créer un service d'administration

Maintenant que vous avez créé votre classe Admin, vous devez créer un service pour cela. Ce service doit avoir la balise sonata.admin, c'est à vous de laisser SonataAdminBundle savoir que ce service particulier représente une classe Admin:
Créez un nouveau fichier admin.xml ou admin.yml dans le dossier Jigar / UserBundle / Resources / config /:
YAML

services:
   sonata.admin.user:
     class: Jigar\UserBundle\Admin\UserAdmin
     tags:
        - { name: sonata.admin, manager_type: orm, group: "User", label: "User" }
     arguments:
        - ~
        - Jigar\UserBundle\Entity\User
        - ~
     calls:
        - [ setTranslationDomain, [JigarUserBundle]]

Maintenant que vous disposez d'un fichier de configuration avec votre service d'administration, il vous suffit d'indiquer à Symfony2 de le charger. Il existe deux façons de le faire:

  • Importation dans le config.yml principal

Incluez votre nouveau fichier de configuration dans le config.yml principal (assurez-vous d'utiliser l'extension de fichier correcte):
YAML

# app/config/config.yml
importations:
     - { resource: @JigarUserBundle/Resources/config/admin.xml }
  • Demandez à votre groupe de le charger

#Jigar/UserBundle/DependencyInjection/JigarUserBundleExtension.php for YAML configurations

use Symfony\Component\DependencyInjection\Loader;
use Symfony\Component\Config\FileLocator;

public function load(array $configs, ContainerBuilder $container)
{
   $configuration = new Configuration();
   $config = $this->processConfiguration($configuration, $configs);

   $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

   $loader->load('services.yml');

   $loader->load('admin.yml');

}

Étape 4: Configuration

À ce stade, vous avez des actions d'administration de base pour votre modèle. Si vous visitez http: //yoursite.local/admin/dashboard à nouveau, vous devriez maintenant voir un panneau avec votre modèle mappé. Vous pouvez commencer à créer, répertorier, éditer et supprimer des instances.

L'image ci-dessus montre la page d'accueil du panneau d'administration qui répertorie les trois entités différentes Utilisateur, Produit et Catégorie.