Installer Polr Admin dans Symfony avec le bundle Sonata Admin

L’agrégateur de sites d’information Africa News Hub utilise deux instances de raccourcisseur d’URL, une pour les liens sortants vers les sites référencés, et une autre pour les liens entrants contenus dans les messages postés sur les réseaux sociaux. Polr, qui se définit comme un raccourcisseur d’URL moderne et robuste, est utilisé sur les deux instances.

Par défaut, avoir deux instances de Polr implique de gérer deux backends séparés, un sur chaque instance. Le package Polr Admin a été créé pour unifier et simplifier la gestion d’un ensemble d’instances de Polr.

Polr Admin est un package qui permet d’administrer une ou plusieurs instances de Polr. Ce n’est pas une application indépendante, mais plutôt une extension à installer dans une application PHP existante. Les fonctions d’authentification sont laissées à la charge de l’application qui l’héberge, et nous n’en parlerons pas dans cet article.

L’interface de Polr Admin s’affiche dans une seule page web, et utilise Ajax pour mettre à jour son contenu. La fonction Ajax est mise en oeuvre avec la librarie Jaxon, qui convertit des classes PHP en classes Javascript, de façon à pouvoir les appeler directement dans le navigateur.

Cet article article décrit l’installation de Polr Admin avec le bundle Sonata Admin, un package qui permet de créer des backends pour le framework Symfony.
Pour Africa News Hub, Polr Admin est intégré dans un backend Laravel. Le choix de Symfony pour cet article a pour but de montrer comment grâce à la librairie Jaxon, Polr Admin peut s’installer sur d’autres frameworks PHP.

Polr Restful API

Le package Polr Admin interagit avec les instances de Polr qu’il administre à l’aide du package Polr API, qui présente les fonctions de Polr dans une API Restful.
Il faut donc installer Polr API sur chaque instance de Polr à administrer.

Le package Polr API s’installe avec Composer.

$ composer require lagdo/polr-api ~0.1

Ensuite, il faut déclarer le package dans le fichier bootstrap/app.php.

$app->register(\Lagdo\Polr\Api\PolrApiServiceProvider::class);

Une fois le package Polr API installé, il faut créer une clé d’API pour un utilisateur sur chaque instance de Polr.
A partir d’ici, il est possible de tester l’accès à l’API avec un outil comme Postman.

Pour la suite, nous allons installer Polr Admin sur un hôte différent. Les deux sections suivantes décrivent l’installation de Symfony et du bundle Sonata Admin.

Installer Symfony

Pour commencer, nous allons installer la version 3.3 de Symfony, en suivant les instructions données sur la page https://symfony.com/doc/3.3/setup.html.

$ curl -LsS https://symfony.com/installer -o ~/bin/symfony
$ chmod a+x ~/bin/symfony
$ symfony new polr-admin 3.3

Une fois l’installation terminée, se déplacer dans le répertoire de Symfony et démarrer le serveur web intégré.

$ cd polr-admin
$ php bin/console server:run

En accédant avec un navigateur à l’adresse http://localhost:8000/, on peut voir la page suivante, qui montre que l’installation s’est bien déroulée.

Accueil Symfony
Accueil Symfony

Installer Sonata Admin Bundle

Le bundle Sonata Admin s’installe avec Composer.

$ composer require sonata-project/admin-bundle

Une fois qu’il est installé, éditer le fichier app/AppKernel.php pour déclarer les bundles de Sonata.

// ...
class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = [
            // ...

            // These are the bundles the SonataAdminBundle relies on
            new Sonata\CoreBundle\SonataCoreBundle(),
            new Sonata\BlockBundle\SonataBlockBundle(),
            new Knp\Bundle\MenuBundle\KnpMenuBundle(),

            // And finally, the storage and SonataAdminBundle
            new Sonata\AdminBundle\SonataAdminBundle(),
        ];

        // ...
    }

    // ...
}

Ensuite, dans le fichier app/config/config.yml, configurer les translations et le bundle Sonata.

framework:
    translator: { fallbacks: [en] }

    # ...

sonata_block:
    default_contexts: [cms]
    blocks:
        # enable the SonataAdminBundle block
        sonata.admin.block.admin_list:
        contexts: [admin]

Enfin, dans le fichier app/config/routing.yml, ajouter les routes du bundle Sonata.

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

Pour terminer l’installation, exécuter les commandes suivantes.

$ php bin/console cache:clear
$ php bin/console assets:install

Le bundle Sonata Admin est maintenant installé, et le lien http://localhost:8000/admin affiche sa page d’accueil, qui est vide pour l’instant.

Accueil Sonata Admin
Accueil Sonata Admin

Installation de Jaxon et Polr Admin

Le package jaxon-php/jaxon-symfony qui fournit les fonctions de Jaxon dans une application Symfony, doit d’abord être installé.
Les vues du package Polr Admin utilisent le moteur de template Blade, ce qui nécessite l’installation du package jaxon-php/jaxon-blade.

$ composer require jaxon-php/jaxon-symfony ~2.0
$ composer require jaxon-php/jaxon-blade
$ composer require lagdo/polr-admin

Une fois l’installation terminée, déclarer le bundle Jaxon dans le fichier app/AppKernel.php.

$bundles = array(
    ...
    new Jaxon\AjaxBundle\JaxonAjaxBundle(),
);

Configurer le bundle Jaxon dans le fichier app/config/config.yml.

imports:
    ...
    - { resource: jaxon.yml }
    - { resource: "@JaxonAjaxBundle/Resources/config/services.yml" }

Pour configurer la librairie Jaxon, créer le fichier app/config/jaxon.yml avec le contenu suivant.

parameters:
jaxon:
    app:
    lib:
        core:
            request:
                uri:     "ajax"
            prefix:
                class:   ""
            js:
                lib:
                app:
                extern:  false
                minify: false
            dialogs:
                default:
                    modal: bootbox
                    alert: noty
                    confirm: noty

Dans cette configuration, le paramètre jaxon.lib.core.request.uri indique que les requêtes Ajax vont être envoyées sur l’URL /ajax. Les paramètres de la section jaxon.lib.core.js indiquent que le code Javascript de Jaxon va être inséré directement dans la page web, et les paramètres de la section jaxon.lib.dialogs indiquent que les fenêtres modales utiliseront la librairie Bootbox, tandis que les messages d’alerte et de confirmation utiliseront la librarie Noty. Les fichiers correspondant seront automatiquement chargés dans la page par Jaxon.

Dans le fichier app/config/routing.yml, définir les deux routes ci-dessous.

polr_index:
    path: /polr
    defaults: { _controller: AppBundle:Polr:index }

polr_jaxon:
    path: /ajax
    defaults: { _controller: AppBundle:Polr:jaxon }
    methods: [POST]

La première est liée à la fonction PolrController::indexAction(), qui va afficher la page de Polr Admin. La seconde est liée à la fonction PolrController::jaxonAction(), qui va traiter les requêtes Ajax de Jaxon.

Voici le code correspondant, à placer dans le fichier src/AppBundle/Controller/PolrController.php.

<?php

namespace AppBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class PolrController extends Controller
{
    private $jaxon;
    private $polr;

    protected function getJaxon()
    {
        $this->jaxon = $this->get('jaxon.ajax');
        $this->polr = $this->jaxon->package('polr.admin');
        $this->polr->config($this->get('kernel')->getProjectDir() . '/app/config/polradmin.yml');
    }

    /**
     * Show the Polr Admin page.
     *
     * @return void
     */
    public function indexAction()
    {
        $this->getJaxon();
        $this->jaxon->register();
        return $this->render('polr.html.twig', [
            'jaxon' => $this->jaxon,
            'polr' => $this->polr,
            'pageTitle' => "Symfony Framework",
        ]);
     }

    /**
     * Process a Jaxon request.
     *
     * @return void
     */
    public function jaxonAction()
    {
        $this->getJaxon();
        // Process the Jaxon request
        if($this->jaxon->canProcessRequest())
        {
            $this->jaxon->processRequest();
        }
    }
}

La fonction PolrController::indexAction() affiche le template app/Resources/views/polr.html.twig dont voici le contenu.

{% extends '@SonataAdmin/standard_layout.html.twig' %}

{% block stylesheets %}
{{ parent() }}

{{ jaxon.css()|raw }}
{{ polr.css()|raw }}
{% endblock %}

{% block javascripts %}
{{ parent() }}

{{ jaxon.js()|raw }}
{{ jaxon.script()|raw }}
{{ polr.js()|raw }}

$(document).ready(function() {
    {{ polr.ready()|raw }}
});

{% endblock %}

{% block page_title 'Welcome to the PolrAdmin Demo application' %}

{% block content_title 'Polr Admin Dashboard' %}

{% block body_id 'polr-admin' %}

{% block body_class 'list' %}

{% block sonata_admin_content %}
{{ parent() }}

{{ polr.html()|raw }}

{% endblock %}

La dernière étape consiste à déclarer les instances de Polr à administrer. Cela se fait dans le fichier app/config/polradmin.yml, dont voici un exemple.

default: first
endpoints:
    first:
        name: First Polr Instance
        url: http://first.domain.tld
        api: api/v2
        key: 012365478978965412300321456987
    second:
        name: Second Polr Instance
        url: http://second.domain.tld
        api: api/v2
        key: 987456321003214569879874563210

Dans cette configuration, le paramètre default désigne l’instance sur laquelle Polr Admin va se connecter par défaut, et la section endpoints contient la liste des instances.

La configuration de Polr Admin est maintenant terminée, et on peut y accéder à l’adresse http://localhost:8000/polr. Voici la page qui s’affiche.

polr-admin-home

L’onglet Settings affiche une liste déroulante où l’utilisateur peut choisir l’instance de Polr à administrer.

polr-admin-settings

Les autres onglets affichent les données de l’instance courante, à savoir la liste des liens de l’utilisateur, la liste de tous les liens, la liste des utilisateurs et les statistiques d’accès aux liens.

polr-admin-user-links
Les liens de l’utilisateur
polr-admin-admin-links
Tous les liens
polr-admin-users
Les utilisateurs
polr-admin-stats
Statistiques

Le code de cet article se trouve en ligne, à cette adresse: https://github.com/lagdo/polr-admin-sonata.

Publicités

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s