integrate laravel and wordpress

Laravel : Intégration avec WordPress.

(Last Updated On: 18 juin 2022)

Alors en intégrant Laravel à WordPress, nous allons développer ici une application qui exporte le contenu directement de Google Doc vers WordPress. Pour commencer, nous allons créer une application sur Laravel pour intégrer l’API Google Doc à WordPress. L’API sera utilisée pour obtenir un document de Google Doc et le publier sur WordPress en tant que blog/publication.

Google Docs est largement utilisé pour rédiger, modifier et partager des documents en ligne. Il permet un accès facile aux documents importants de n’importe où et n’importe quand. C’est l’un de ces premiers traitements de texte qui a introduit l’édition de documents en ligne, permettant aux équipes d’améliorer leur processus de travail et leur collaboration pour les projets.

De nombreux blogueurs, éditeurs et journalistes utilisent Google Doc et WordPress pour écrire et publier leur contenu. Mais, tous ont tendance à faire face à un problème commun, à savoir comment exporter/transférer du contenu directement de Google Doc vers WordPress au lieu de le copier/coller.

Nous allons donc créer une application sur Laravel pour intégrer l’API Google Doc à WordPress. L’API sera utilisée pour obtenir un document de Google Doc et le publier sur WordPress en tant que blog/publication.

Intégration de Laravel et WordPress

Conditions préalables

Pour tirer le meilleur parti de ce didacticiel d’intégration Laravel et WordPress, vous devez d’abord configurer ces deux applications sur Cloudways . La plate-forme fournit une solution d’hébergement Laravel à la pointe de l’industrie, basée sur une incroyable pile d’outils, notamment Varnish, Redis, Memcache et autres.

Ensuite, installez un plugin d’authentification de base pour WordPress, ainsi qu’un package Guzzlehttp et un package API Google pour votre application Laravel. 

Intégration de Laravel à l’API Google Doc

Inscrivez-vous avec l’API Google

Pour intégrer une application Laravel, connectez-vous d’abord à votre compte Google . Accédez ensuite à la Google Developers Console et créez ou sélectionnez un projet existant.

Cliquez maintenant sur “Continuer” et accédez aux informations d’identification.

Choisissez l’API Google Drive, sélectionnez Web Server et vérifiez les données utilisateur.

Entrez le nom de l’ID client et entrez la route Laravel comme URL de redirection. Entrez votre nom de domaine au lieu de l’adresse de l’hôte local pour la production. L’URL de redirection sera utilisée pour rediriger les utilisateurs vers votre application après l’authentification. Créez un ID client et entrez le nom du produit. Ensuite, téléchargez le fichier d’informations d’identification JSON et enregistrez-le.

Maintenant, cliquez sur Activer l’API et les services dans le tableau de bord.

Maintenant, recherchez les API Google Drive et Google+ et assurez-vous que les deux sont activés.

Ensuite, installez le package de l’API Google.

composer require google/apiclient
CONFIGURE GOOGLE SERVICE
GOOGLE_APP_ID=
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=
GOOGLE_REDIRECT_URL=
GOOGLE_SCOPES="https://www.googleapis.com/auth/drive.readonly"
GOOGLE_APPROVAL_PROMPT="force"
GOOGLE_ACCESS_TYPE="offline"

Ajoutez ces informations d’identification à votre fichier .env et ajoutez votre APP_ID, CLIENT_ID, CLIENT_SECRET, REDIRECT_URL à vos propres informations d’identification à partir du fichier JSON que vous avez téléchargé précédemment.

Ici, nous utilisons https://www.googleapis.com/auth/drive.readonly comme portée pour obtenir l’autorisation de lire le contenu de Google Drive.

Maintenant, créez une classe Google en tant que App\Google.php :

<?php

namespace App;
class Google

{
    public function client()
    {
        $client = new \Google_Client();
        $client->setClientId(env('GOOGLE_CLIENT_ID'));
        $client->setClientSecret(env('GOOGLE_CLIENT_SECRET'));
        $client->setRedirectUri(env('GOOGLE_REDIRECT_URL'));
        $client->setScopes(explode(',', env('GOOGLE_SCOPES')));
        $client->setApprovalPrompt(env('GOOGLE_APPROVAL_PROMPT'));
        $client->setAccessType(env('GOOGLE_ACCESS_TYPE'));

        return $client;

    }

    public function doc($client)

    {
        $doc = new \Google_Service_Docs($client);
        return $doc;
    }

    public function drive($client)

    {
        $drive = new \Google_Service_Drive($client);
        return $drive;
    }

    public function service($client)

    {
        $service = new \Google_Service_Books($client);
        return $service;
    }
}

Le code ci-dessus établit une connexion avec le client Google en transmettant les informations d’identification de votre fichier .env à la classe. Pour obtenir le service Google Drive, vous devez transmettre la fonction client qui est également les informations d’identification du \Google_service_drive. Il vous aide à accéder aux fichiers de votre Google Drive et à les modifier selon les exigences. De même pour la fonction doc qui permet d’accéder au contenu de votre dossier de documents et de le modifier selon les besoins.

Commençons par le noyau Laravel. Tout d’abord, nous allons créer nos contrôleurs tels que définis ci-dessous :

  • php artisan make:controller AuthController;
  • php artisan make:controller GoogleController;

Le Authcontroller gérera notre authentification et redirection auth0, tandis que le GoogleController se chargera d’obtenir le contenu du document à partir de l’API du lecteur et de le publier sur l’API WordPress.

Créons notre route à partir des routes \web.php :

Route::get ( '/login/google' , 'AuthController@redirectToGoogleProvider' ) ;
Route::get ( '/login/google/callback' , 'AuthController@handleProviderGoogleCallback' ) ;
Route::get ( '/post/blog' , 'GoogleController@handlePost' ) ;

La route /login/google/callback est l’URL de redirection utilisée lors de la configuration d’une API Google.

Commençons par le AuthController :

<?php

namespace App\Http\Controllers;
use App\Google;
use Illuminate\Http\Request;

class AuthController extends Controller
{
    //
    public function index(){
    return view('home');
    }
    public function __construct(Google $google, Request $request)
    {
        $this->client = $google->client();
        $this->drive = $google->drive($this->client);
    }
    public function redirectToGoogleProvider(GoogleDoc $googleDoc)
    {
        $client = $googleDoc->client();
        $auth_url = $client->createAuthUrl();
        return redirect($auth_url);
    }

    public function handleProviderGoogleCallback(Request $request)
    {
        if($request->has('code')){
            $client = $this->client;
            $client->authenticate($request->input('code'));
            $token = $client->getAccessToken();
            $request->session()->put('access_token',$token);
           return redirect('/home')->with('success','you have been authenticated');
        }else{
            $client=$googleDoc->client();
            $auth_url = $client->createAuthUrl();
            return redirect($auth_url);
        }
    }
}

La ToGoogleProvider() méthode demande à l’utilisateur l’autorisation de gérer les données Drive, c’est-à-dire en demandant le compte Google réel.

La handleProviderGoogleCallback() méthode nous permet d’obtenir le jeton qui a été transmis par la redirectToGoogleProvider()  méthode. Nous pouvons également utiliser cette méthode dans les sessions en tant que access_token, pour réduire les actions répétitives pour envoyer une requête à l’API Google Drive.

Avant de passer à notre GoogleController qui se chargera de notre intégration, nous allons d’abord configurer WordPress.

Configuration de WordPress

Comme défini ci-dessus dans les prérequis, nous avons déjà configuré WordPress, et maintenant nous allons télécharger et installer le plugin d’authentification de base qui gérera notre processus d’authentification.

Remarque : Ce plugin nécessite l’envoi de votre nom d’utilisateur et de votre mot de passe avec chaque demande, et ne doit être utilisé qu’à des fins de développement et de test, c’est-à-dire pas dans un environnement de production. D’autres plugins tels que JSON Web Tokens , etc. peuvent être utilisés en production.

Pour en revenir à notre application Laravel, nous allons d’abord installer le package Guzzlehttp qui est assez pratique pour travailler avec les requêtes HTTP. Fondamentalement, il s’agit d’un client HTTP PHP qui facilite l’envoi et la réception de requêtes HTTP à intégrer aux services Web.

Installation de Guzzle

composer require guzzlehttp/guzzle:~6.0

Collez le code suivant dans GoogleController :

GoogleController

<?php

namespace App\Http\Controllers;
use App\Google;
use GuzzleHttp\Client;
use Illuminate\Http\Request;

class GoogleController extends Controller
{
public function __construct(Google $google, Request $request)
{
    $this->client = $google->client();
    $this->drive = $google->drive($this->client);
}
public function handlePost(Request $request)
{
global $image_url;
if ($request->session()->get('access_token')){
    $client=$this->client;
    $client->setAccessToken($request->session()->get('access_token'));
//getting document from drive that contain 'blog'
            $pageToken = NULL;
            $optParams = [
                    'q'=>"name contains 'blog'",
                    'spaces'=>"drive",
                    'fields' =>"nextPageToken, files(id, name)",
                    'pageToken'=>$pageToken
            ];
            $respon = $this->drive->files->listFiles($optParams)->getFiles();
            foreach ($respon as $respons) {
                //getting the content of the documents
                $file = new \Google_Service_Docs($client);
                $document = $respons['id'];
                $doc = $file->documents->get($document);
                $contents = $doc->getBody()->getContent();
                $datas = [];
                for ($i = 0; $i < count($contents); $i++) {
                    if ($contents[$i]->getParagraph() == null) {
                        continue;
                    }
                    $table = $contents[$i]->getParagraph()->getElements();
                    for ($j = 0; $j < count($table); $j++) {
                        if ($table[$j]->getTextRun() == null) {
                            goto image;
                        }
                        $cell = $table[$j]->getTextRun()->getContent();
                        array_push($datas, $cell);
                        image:
                        if ($table[$j]->getInlineObjectElement() == null) {
                            continue;
                        }
                        $image_id = $table[$j]->getInlineObjectElement()->getInlineObjectId();
                        $url = $doc->getInlineObjects();

                        $image_url2 = "<img " . "src" . "=" . $url[$image_id]->getInlineObjectProperties()->getEmbeddedObject()->getImageProperties()->contentUri . ">";
                        array_push($datas, $image_url2);
                        $image_url = $url[$image_id]->getInlineObjectProperties()->getEmbeddedObject()->getImageProperties()->contentUri;
                    }
                }
//connection to wordpress api
                $username = 'admin';
                $password = 'admin';
                $client = new Client([
                    'base_uri' => 'http://localhost:8888/wordpress/wp-json/wp/v2/',
                    'headers' => [
                        'Authorization' => 'Basic ' . base64_encode($username . ':' . $password),
                        'Accept' => 'application/json',
                        'Content-type' => 'application/json',
                        'Content-Disposition' => 'attachment',
                    ]
                ]);

                // uploading featured image to wordpress media and getting id
                $name = $doc->getTitle() . '.' . 'jpg';
                $responses = $client->post(
                    'media',
                    [
                        'multipart' => [
                            [
                                'name' => 'file',
                                'contents' => file_get_contents($image_url),
                                'filename' => $name
                            ],
                        ]
                    ]);
                $image_id_wp = json_decode($responses->getBody(), true);
// uploading post to wordpress with featured image id
                $response = $client->post('posts', [
                    'multipart' => [
                        [
                            'name' => 'title',
                            'contents' => $doc->getTitle()
                        ],
                        [
                            'name' => 'content',
                            'contents' => implode("", $datas)
                        ],
                        [
                            'name' => 'featured_media',
                            'contents' => $image_id_wp['id']
                        ],
                    ]
                ]);            
            }
    return redirect('/home')->with('success','post has been created');
}else{
   return redirect('/home')->with('error','you have not been authenticated');
}
}
}

La première chose est de mettre le access_token en session. Ensuite, nous obtiendrons notre ID de documents à partir de Google Drive en passant le $optParams[]à la  listfiles()méthode. Le $optParams[]spécifie le type de fichier et de répertoire auquel nous essayons d’accéder, qui dans notre cas est n’importe quel fichier qui a ‘blog’ dans son nom dans le répertoire racine.

Remarque : Vous devez inclure “blog” dans le nom de chaque document que vous publiez. Vous pouvez toujours modifier les valeurs de $optParams[].

$pageToken = NULL;

            $optParams = [

                    'q'=>"name contains 'blog'",

                    'spaces'=>"drive",

                    'fields' =>"nextPageToken, files(id, name)",

                    'pageToken'=>$pageToken

            ];

            $respon = $this->drive->files->listFiles($optParams)->getFiles();

L’étape suivante consiste à parcourir tous les documents et à obtenir leur contenu en transmettant l’ID du document à la méthode get() de la classe Google_service_Docs.

Obtenir le contenu du document

La getContent()méthode appelée depuis la getBody()méthode affiche le contenu du document dans un tableau, c’est-à-dire que chaque ligne de votre document est considérée comme un index du fichier getContent().

En parcourant le tableau getContent(), nous obtiendrons la méthode getElements() qui est également un tableau().

Une boucle dans le getElements()nous permettra d’accéder au getTextRun()->getContent() qui affiche la valeur du premier paragraphe de votre document.

Nous essaierons également d’obtenir l’ID des images du document en utilisant la getInlineObjectElement()méthode de la méthode getParagraph()->getElements(). Ensuite, nous passerons l’imageID comme index à la méthode $doc->getInlineObjects() pour obtenir l’URL de l’image.

Chaque ligne de votre document est ensuite poussée vers le tableau $data, de sorte que le contenu sera exactement le même que dans le document d’origine.

$file = new \Google_Service_Docs($client);

                $document = $respons['id'];

                $doc = $file->documents->get($document);

                $contents = $doc->getBody()->getContent();

                $datas = [];

                for ($i = 0; $i < count($contents); $i++) {

                    if ($contents[$i]->getParagraph() == null) {

                        continue;

                    }

                    $table = $contents[$i]->getParagraph()->getElements();

                    for ($j = 0; $j < count($table); $j++) {

                        if ($table[$j]->getTextRun() == null) {

                            goto image;

                        }

                        $cell = $table[$j]->getTextRun()->getContent();

                        array_push($datas, $cell);

                        image:

                        if ($table[$j]->getInlineObjectElement() == null) {

                            continue;

                        }

                        $image_id = $table[$j]->getInlineObjectElement()->getInlineObjectId();

                        $url = $doc->getInlineObjects();

                        $image_url2 = "<img " . "src" . "=" . $url[$image_id]->getInlineObjectProperties()->getEmbeddedObject()->getImageProperties()->contentUri . ">";

                        array_push($datas, $image_url2);

                        $image_url = $url[$image_id]->getInlineObjectProperties()->getEmbeddedObject()->getImageProperties()->contentUri;

                    }

                }

Connexion à l’API WordPress

Maintenant, en utilisant le package guzzlehttp, nous allons configurer l’autorisation d’URL de l’API WordPress en passant le tableau d’en-tête[], qui utilisera notre nom d’utilisateur et mot de passe WordPress encodés en base64.

//connection to wordpress api

                $username = 'admin';

                $password = 'admin';

                $client = new Client([

                    'base_uri' => 'http://localhost:8888/wordpress/wp-json/wp/v2/',

                    'headers' => [

                        'Authorization' => 'Basic ' . base64_encode($username . ':' . $password),

                        'Accept' => 'application/json',

                        'Content-type' => 'application/json',

                        'Content-Disposition' => 'attachment',

                    ]

                ]);

Téléchargement de l’image sélectionnée de la publication

Chaque publication WordPress a une image en vedette qui s’affiche sur la page d’accueil. Nous téléchargerons l’image sélectionnée sur notre média WordPress en utilisant le point de terminaison de l’API WordPress pour le média.

Remarque : sur la base de cet article, la dernière image de votre document sera l’image sélectionnée pour la publication WordPress.

Ensuite, nous passerons la variable $image_url déclarée comme globale, à la méthode file_get_contents comme contenu du message. De plus, le nom du fichier doit être spécifié, avec une extension d’image (jpg, png, etc.).

// uploading featured image to wordpress media and getting id

                $name = $doc->getTitle() . '.' . 'jpg';

                $responses = $client->post(

                    'media',

                    [

                        'multipart' => [

                          [

                           'name' => 'file',

                           'contents' => file_get_contents($image_url),

                           'filename' => $name

                          ],

                        ]

                    ]);

                $image_id_wp = json_decode($responses->getBody(), true);

Il renverra une réponse JSON, afin que nous puissions obtenir l’ID de l’image en vedette et le transmettre avec le message.

Télécharger votre article sur WordPress

Enfin, nous allons maintenant télécharger notre document Word en tant que publication dans WordPress. On passera le nom du document comme titre du post avec la $getTitle()méthode.

Le contenu de la publication sera le document qui est poussé vers $data[]. Mais nous devrons passer le $data[] au implode(), afin de le convertir en variable avant de le télécharger sur le post.

L’image sélectionnée sera l’ID d’image sélectionnée que nous avons obtenu de la réponse JSON après avoir téléchargé l’image sur le média WordPress.

// uploading post to wordpress with featured image id

                $response = $client->post('posts', [

                    'multipart' => [

                        [

                           'name' => 'title',

                           'contents' => $doc->getTitle()

                        ],

                        [

                           'name' => 'content',

                           'contents' => implode("", $datas)

                        ],

                        [

                           'name' => 'featured_media',

                           'contents' => $image_id_wp['id']

                        ],

                    ]

                ]);

Derniers mots

Cela nous amène à la fin de cet article, qui a montré en détail comment intégrer Google Docs à WordPress à l’aide du framework Laravel. En tant que blogueur ou rédacteur de contenu, il semble souvent assez fastidieux de copier et coller manuellement tout le contenu de Google Docs vers WordPress. Cela prend du temps, nécessite des efforts supplémentaires et est parfois confondu avec le contenu réel du document.

C’est pourquoi cet article sur l’intégration de Laravel et WordPress est destiné à toutes les personnes qui souhaitent rationaliser leur travail de publication. Cela rend le processus d’écriture et de publication super facile et sans tracas.

Si vous avez encore des questions ou souhaitez ajouter vos suggestions à cet article, n’hésitez pas à les écrire dans la section des commentaires ci-dessous.

Source : https://www.cloudways.com/


Merci de votez pour cet article :
Votez : Pas malMoyenBienAcès bienExcélent (1 votes, average: 2,00 out of 5)
Loading...

Laisser un commentaire

Translate »