Viele Internetseiten und Webshops bieten heutzutage Paypal als Bezahlungs-Gateway an, denn Paypal zählt zu den schnellsten und sichersten Bezahlsystemen weltweit. In diesem Artikel zeige ich Dir, wie Du die von Paypal auf Github bereitgestellte PHP SDK in Dein Laravel – Projekt integrieren kannst. Außerdem werden wir die Laravel Authentication aktivieren und über eine Datenbank Migration die Spalten „paypal_agreement_status“ und „paypal_agreement_id“ zur Benutzer Tabelle hinzufügen. Dadurch kannst Du Paypal Bezahl-Abonnements einem Benutzer zuordnen, den Status des Abonnements im Auge behalten und diesen gegebenenfalls aktuallisieren.

Die Paypal PHP SDK

Paypal bietet unter seinem Github Account eine eigene PHP SDK an (Github – Paypal php sdk). Durch die SDK kannst Du spielend leicht die Paypal Rest-API ansteuern, um bspw.:

• Einzelne Bezahlungen zu integrieren
• Den Status eines Bezahlvorgangs per Token abzurufen
• Bezahl-Abonnements zu planen (Billing plans)
• Abonnement-Verträge (agreements) nach Vorlage geplanter Abonnements anzulegen
• Den Status eines Abonnement-Vertrages abzurufen
• Einen Abonnement-Vertrag zu pausieren, oder zu re-aktivieren

Im Zuge dieses Artikels werde Ich Dir Schritt für Schritt zeigen wie Du die SDK in Dein Projekt einbindest, wie Du „billing plans“ anlegst und wie Du diese verwenden kannst um Abonnements zu erstellen. Zum Schluss zeige ich Dir noch, wie Du mit Hilfe der „agreement_id“ eines laufenden Abonnements dessen Status abfragen kannst (bspw.: aktiv, pausiert, beendet). Eine Dokumentation über die SDK von Paypal findest Du unter: Github – Paypal php sdk

Integration der Paypal PHP SDK – Paypal in Laravel integrieren

Schritt 1 – Einrichtung des Laravel Projektes

Dadurch, dass die PHP SDK als Repository auf Github bereitgestellt wird und das Repository über eine „composer.json“ verfügt, kannst Du es einfach als Abhängigkeit in die „composer.json“ Deiner Laravel Anwendung integrieren. Aber zunächst solltest Du mit Hilfe von Composer Dein Laravel Projekt über die Konsole/das Terminal anlegen, sofern das noch nicht geschehen ist. Füge bei „myApplication“ den Name Deiner Laravel Anwendung ein:

$ composer create-project --prefer-dist laravel/laravel myApplication

Solltest Du Composer noch nicht kennen, dann kannst Du unter Get Composer mehr über den PHP Paket-Manager erfahren. Dort findest Du eine Installationsanleitung, einen Artikel der Dich in die Benutzung von Composer einführt und auch eine Dokumentation.
Nachdem Du nun ein Projekt besitzt, kannst Du die benötigten Github Repositories mit Hilfe von Composer in Dein Projekt integrieren. Zunächst integrierst Du das Paket „paypal/rest-api-sdk-php“ per Konsolenbefehl:

$ composer require paypal/rest-api-sdk-php

Um auf einem einfachen Weg Http Anfragen von Deiner Laravel Anwendung zu versenden, kannst Du das Github Repository „Guzzle“ verwenden. Dadurch wird das Ansprechen der Rest-API erleichtert. Solltest Du „Guzzle“ also noch nicht verwenden, so kannst Du es mit Hilfe von Composer über die Konsole integrieren:

$ composer require guzzlehttp/guzzle

Schritt 2 – Vorbereitung der Datenbankanbindung

Nun bereitest Du die Anbindung von Laravel an die Datenbank vor. Zu aller erst legst Du auf Deinem Datenbankserver eine Datenbank für das Projekt an. Danach hinterlegst Du die DB Informationen in der „.env“ Datei. Wie die Datenbankanbindung im Detail abläuft, erfährst Du unter Laravel 5.5 – Database.
Wärend späterer Datenbank-Migrationen ist es auch nützlich eine Standartlänge für Datenbank „strings“ festzulegen. Dadurch ersparst Du Dir unnötige Fehler und Schreibarbeit. Um die Standartlänge festzulegen kannst Du unter „myApplication/app/Providers“ den Provider „AppServiceProvider“ öffnen und fügst dort den Namespace „IlluminateSupportFacadesSchema“ hinzu. Danach musst Du in der Funktion „boot“ nurnoch folgenden Funktionsaufruf intergerieren:

public function boot()
{
     Schema::defaultStringLength(150);
}

Schritt 3 – Laravel User Authentication aktivieren

Um die von Laravel mitgelieferte User Authentication nutzen zu können, musst Du sie vorher „aktivieren“. Dabei hilft Dir das Laravel-Tool Artisan. Artisan ist eine PHP Anwendung, die Du parametrisiert in der Konsole ausführen kannst und die für Dich diverse Aufgaben rund um Deine Laravel Anwendung ausführt. Mit dem folgenden Befehl erstellt Artisan alle benötigten Komponenten wie Model, Views, Controller und Routen:

$ php artisan make:auth

Nun legst Du eine neue Migrationsdatei an, damit Deine Benutzer die zu Beginn erwähnten Spalten „paypal_agreement_status“ und „paypal_agreement_id“ erhalten. Eine Migration legst Du ebenfalls über Artisan an, wobei Du nach dem „make“ Befehl noch einen aussagekräftigen Namen für die Migrationsdatei angeben solltest:

$ php artisan make:migration add_paypal_agreement_to_user

Nun öffnest Du die gerade erstellte Migration. Diese findest Du unter „myApplication/database/migrations“. In dieser Datei gibt es nun zwei leere Methoden, „up“ und „down“. Füge nun folgenden Code in die „up“ – Funktion ein:

public function up() {
	Schema::table('users', function($table) {
		$table->integer('paypal_agreement_id');
		$table->string('paypal_agreement_status');
	}
}

Dem Status („paypal_agreement_status“) wird später der enum Wert der „state“ Eigenschaft vom Rest API Aufruf zugewiesen. Dazu verwendest Du später die Rest API „v1/payments/billing-agreements/agreement_id“ (Paypal Developer Docs – Billing agreements).
Um einen sauberen Rollback durchführen zu können muss noch die „down“ – Funktion implementiert werden. In dieser tauscht Du die Datentypen einfach gegen die Funktion „dropColumn“:

public function down() {
	Schema::table('users', function($table) {
		$table->dropColumn('paypal_agreement_id');
		$table->dropColumn('paypal_agreement_status');
	}
}

Damit die nun erstellte Migration und die vorherigen Migrationen in die Datenbank eingespielt werden, musst Du einen Artisan Konsolenbefehl ausführen:

$ php artisan migrate

Die Migrationen werden dadurch in die Datenbank überspielt und Du kannst die von Laravel mitgelieferte User Authentication nutzen.

Schritt 4 – Erstellen der Paypal Config Datei

Als nächstes erstellst Du eine Konfigurationsdatei in der alle Einstellungen und Schlüssel von Paypal hinterlegt werden. Die Datei erstellst Du unter „myApplication/config“ mit dem Dateinamen „paypal.php“:

<?php
return array(
    /**
     * Sandbox und Live credentials
     */
    'credentials' => array(
        'sandbox' => array(
            'client_id' => env('PAYPAL_SANDBOX_CLIENT_ID', ''),
            'secret' => env('PAYPAL_SANDBOX_SECRET', '')
        ),
        'live' => array(
            'client_id' => env('PAYPAL_LIVE_CLIENT_ID', ''),
            'secret' => env('PAYPAL_LIVE_SECRET', '')
        ),
    ),
    /**
     * SDK Konfiguration
     */
    'settings' => array(
        /**
         * Payment Mode
         *
         * Optionen: 'sandbox' oder 'live'
         */
        'mode' => env('PAYPAL_MODE', 'sandbox'),

        // Angabe in Sekunden
        'http.ConnectionTimeOut' => 3000,
        'log.LogEnabled' => true,
        'log.FileName' => storage_path() . '/logs/paypal.log',

        /**
         * Log Level
         *
         * Optionen: 'DEBUG', 'INFO', 'WARN' oder 'ERROR'
         */
        'log.LogLevel' => 'DEBUG'
    ),
);

In der Paypal Konfiguration werden die Schlüssel „client_id“ und „secret“ für den Sandbox und Live Modus mit der PHP Funktion „env()“ geladen. Diese müssen nun noch in der „.env“ Datei hinterlegt werden, die Werte folgen im Anschluss:

PAYPAL_MODE=

PAYPAL_SANDBOX_CLIENT_ID=
PAYPAL_SANDBOX_SECRET=

PAYPAL_LIVE_CLIENT_ID=
PAYPAL_LIVE_SECRET=

Schritt 5 – Registrieren der Anwendung in Paypal

Nun musst Du Deine Anwendung bei Paypal registrieren, um die „client_id“ sowie den „secret“ Code für den jeweiligen Modus zu erhalten. Dazu besuchst Du: Paypal Developer und meldest Dich mit Deinen Benutzerdaten unter „Log into Dashboard“ an.

 

 

Nach dem Login kommst Du auf Dein Paypal Development Dashboard. Wenn Du auf diesem runterscrollst bis zur Sektion „REST API apps“, dann kannst Du über den Knopf „Create App“ eine neue Rest API Anwendung zu Deinem Account hinzufügen.

 

 

Wenn Du auf „Create App“ geklickt hast, öffnet sich die Maske zur Erstellung einer neuen Anwendung. In dieser trägst Du den Namen Deiner Anwendung ein und wählst den „facilitator“ Sandbox Developer Account aus. Dieser sollte im Normalfall automatisch erstellt werden. Wenn die erste Erstellung des Accounts noch nicht geklappt hat, schlägt die Erstellung der Anwendung ebenfalls fehl. Versuche es einfach nach einer Weile erneut.

 

 

Nachdem die Anwendung erfolgreich erstellt wurde, gelangst Du auf die Detailansicht Deiner Anwendung. Auf dieser findest Du die benötigten Ids und secret Codes. Oberhalb der Box „Sandbox API Credentials“ findest Du zwei Knöpfe um zwischen dem Sandbox und dem Live Modus zu wechseln.

 

 

Wenn Du auf „Show“ unter „Secret“ klickst, erweitert sich das Panel und Du kannst den jeweiligen Secret Code sehen.

 

 

Nun kopierst Du die Schlüssel und fügst sie in die „.env“ Datei ein:

PAYPAL_MODE=sandbox

PAYPAL_SANDBOX_CLIENT_ID=hier-steht-normalerweise-eine-lange-client-id
PAYPAL_SANDBOX_SECRET=hier-steht-normalerweise-ein-langer-secret-code

PAYPAL_LIVE_CLIENT_ID=hier-steht-normalerweise-eine-lange-client-id
PAYPAL_LIVE_SECRET=hier-steht-normalerweise-ein-langer-secret-code

Schritt 6 – Erstellung des Paypal Controllers

Die „.env“ Datei ist gefüllt und Du kannst jetzt den Laravel Controller zur Verwaltung der Paypal PHP SDK erstellen. Dabei hilft Dir wieder Artisan:

$ php artisan make:controller PaypalController

Artisan hat nun für Dich einen leeren Controller mit dem Namen „PaypalController.php“ im Verzeichnis „myApplication/app/Http/Controllers“ angelegt. In diesen fügst Du nun folgende Namespaces hinzu:

use PayPalApiChargeModel;
use PayPalApiCurrency;
use PayPalApiMerchantPreferences;
use PayPalApiPaymentDefinition;
use PayPalApiPlan;
use PayPalApiPatch;
use PayPalApiPatchRequest;
use PayPalCommonPayPalModel;
use PayPalRestApiContext;
use PayPalAuthOAuthTokenCredential;

Als nächstes benötigst Du noch einige Felder um die Paypal Daten auf der Konfiguration zwischenzuspeichern. Diese integriest Du am besten ganz oben in Deinem Controller:

private $apiContext;
private $mode;
private $client_id;
private $secret;

Diese Felder füllst Du nun über den Konstruktor. Hier kommt auch die zuvor erstellte Konfiguration zum Einsatz:

public function __construct() {
    // Zunächst wird geprüft, in welchem Modus sich die App befindet
    if(config('paypal.settings.mode') == 'live'){
        $this->client_id = config('paypal.credentials.live.client_id');
        $this->secret = config('paypal.credentials.live.secret');
    } else {
        $this->client_id = config('paypal.credentials.sandbox.client_id');
        $this->secret = config('paypal.credentials.sandbox.secret');
    }

    // Nun legst Du den Paypal API Context fest
    $oAuthToken = new OAuthTokenCredential($this->client_id, $this->secret)
    $this->apiContext = new ApiContext();
    $this->apiContext->setConfig(config('paypal.settings'));
}

Durch das Setzen des Kontextes im Konstruktor können wir in den Funktionen des Controllers immer mit dem korrekten Kontext arbeiten. Wichtig ist, dass wir alle API Zugriffe in einem Try-Catch Block unterbringen, da gegebenenfalls ein Zugriffsfehler („PayPalConnectionException“) auftreten kann.

Schritt 7 – Erstellung einer Paypal Abonnement Vorlage

Nun kannst Du mit Hilfe Deiner Paypal Konfiguration und der Schlüssel eine Vorlage für ein Bezahl-Abonnement erstellen und aktivieren. Dies ist notwendig, damit die Benutzer später Abonnements abschließen zu können. Paypal benötigt für ein „Billing agreement“ zuerst einen „Billing plan“ als Vorlage.
In dem folgenden Beispiel benötigst Du die Funktion zum Anlegen der Vorlage nur ein mal, danach kann sie theoretisch entfernt werden. Du kannst natürlich einen komplexeren Workflow entwickeln, in dem administrative Nutzer Vorlagen für Abonnements mit Hilfe dieser Methode anlegen können. In diesem Fall müsstest Du die generierten Plan Ids in einer Datenbank speichern und nicht in der „.env“ Datei.
Erstelle nun unterhalb des Konstruktors die Funktion „create_billing_plan“:

public function create_billing_plan() {
        // Erstelle einen neuen Plan
        $plan = new Plan();
        $plan->setName('myApplication - Monatsabonnement')
          ->setDescription('Monatlich abgerechnetes Abonnement der App myApplication')
          ->setType('infinite');

        // Nun definierst Du die Bezahlparameter
        $paymentDefinition = new PaymentDefinition();
        $paymentDefinition->setName('Regelmäßige Bezahlung')
          ->setType('REGULAR')
          ->setFrequency('Month')
          ->setFrequencyInterval('1')
          ->setCycles('0')
          ->setAmount(new Currency(array('value' => 15, 'currency' => 'EUR')));

        // An dieser Stelle definierst Du die Anbieter Einstellungen
        $merchantPreferences = new MerchantPreferences();
        $merchantPreferences->setReturnUrl('https://myapplication.dev/subscribe/paypal/return')
          ->setCancelUrl('https://myapplication.dev/subscribe/paypal/return')
          ->setAutoBillAmount('yes')
          ->setInitialFailAmountAction('CONTINUE')
          ->setMaxFailAttempts('0');

        $plan->setPaymentDefinitions(array($paymentDefinition));
        $plan->setMerchantPreferences($merchantPreferences);

        // Jetzt ist alles vorbereitet, der Plan kann also bei Paypal erstellt werden
        try {
            $createdPlan = $plan->create($this->apiContext);

            try {
                $patch = new Patch();
                $value = new PayPalModel('{"state":"ACTIVE"}');
                $patch->setOp('replace')
                  ->setPath('/')
                  ->setValue($value);
                $patchRequest = new PatchRequest();
                $patchRequest->addPatch($patch);
                $createdPlan->update($patchRequest, $this->apiContext);
                $plan = Plan::get($createdPlan->getId(), $this->apiContext);

                // Zum Schluss wird noch die ID ausgegeben, wenn alles geklappt hat
                echo 'Vorlagen ID für das Abonnement: ' . $plan->getId();
            } catch (PayPalExceptionPayPalConnectionException $ex) {
                echo $ex->getCode();
                echo $ex->getData();
                die($ex);
            } catch (Exception $ex) {
                die($ex);
            }
        } catch (PayPalExceptionPayPalConnectionException $ex) {
            echo $ex->getCode();
            echo $ex->getData();
            die($ex);
        } catch (Exception $ex) {
            die($ex);
        }
    }
}

In dieser Funktion ist nun einiges Integriert. Du kannst die Funktion selbstverständlich noch refaktorisieren, wenn Du sie in einen komplexeren Workflow einbetten willst.
Zu Beginn der Funktion legst Du einen neuen Plan an und initialisierst die benötigten Eigenschaften wie die Bezahlparameter und den Anbieter.
Deine definierte Vorlage hat folgenden Aufbau:

• Name: „myApplication – Monatsabonnement“
• Beschreibung: „Monatlich abgerechnetes Abonnement der App myApplication“
• Typ: „infinite“
• Bezahlparameter:
  • Name: „Regelmäßige Bezahlung“
  • Type: „REGULAR“
  • Abbuchung: „Month“
  • Abbuchungsintervall: „1“
  • Anzahl der Zahlungen: „0“ (durch Type: „infinite“)
  • Betrag: „15 Euro“
• Anbieter Einstellungen:
  • URL zur Zahlungsbestätigung: „https://myapplication.dev/subscribe/paypal/return“
  • URL zum Zahlungsabbruch: „https://myapplication.dev/subscribe/paypal/return“
  • Sollen unbezahlte Beträge im nächsten Zyklus mitabgebucht werden: „yes“
  • Aktion beim Fehlschlagen der ersten Abbuchung: „CONTINUE“ (Der Betrag wird bei der nächsten Abbuchung addiert)
  • Maximale Fehler beim Abbuchen: „0“ (unbegrenzt)

Wichtig ist, dass Du die Domain im Beispiel gegen Deine Domain tauscht. Weiterhin kann es sein, dass es Probleme mit Links geben kann, in denen ein Port angegeben ist (bspw.: „http://localhost:8080/subscribe/paypal/return“). Am besten Du legst einen V-Host über Deinen lokalen Webserver an (bspw.: „http://local-app.dev/“), dann hast Du damit keine Probleme.
Nun öffnest Du die Routen-Datei „web.php“ unter „myApplication/routes“ und trägst folgende Route zu der „create_billing_plan“ Funktion ein:

Route::get('/create-plan', 'PaypalController@create_billing_plan');

Wenn Du nun im Browser die Url „http://myapplication.dev/create-plan“ aufrufst, wird die „billing plan id“ ausgegeben. Diese Id kannst du nun in der „.env“ Datei hinterlegen:

PAYPAL_SANDBOX_PLAN_ID=hier-steht-normalerweise-eine-plan-id
PAYPAL_LIVE_PLAN_ID=hier-steht-normalerweise-eine-plan-id

Wenn Du mit Deiner Website in den Live Modus gehen willst, musst Du die Url noch mal im Live Modus aufrufen, damit die Vorlage auch für diesen Angelegt wird.Wichtig ist, dass Du daran denkst, die Route in der Routen Datei „web.php“ auszukommentieren, wenn Du sie nicht mehr benötigst.

// Route::get('/create-plan', 'PaypalController@create_billing_plan');

Schritt 8 – Eintragung der Paypal Routen

Trage nun die produktiven Routen für Deinen Paypal Controller in die „web.php“ Routen Datei ein:

Route::get('/subscribe/paypal', 'PaypalController@paypal_redirect')->name('paypal.redirect');
Route::get('/subscribe/paypal/return', 'PaypalController@paypal_return')->name('paypal.return');

Schritt 9 – Abonnements im Paypal Controller anlegen

Nun fügst Du noch die beiden vorher angelegten Routen als Funktionen zu Deinem Paypal Controller hinzu, davor musst Du aber noch die „billing plan“ Id aus der env Datei laden. Dies passiert im Konstruktor:

private $apiContext;
private $mode;
private $client_id;
private $secret;
private $plan_id;

public function __construct() {
    // Zunächst wird geprüft, in welchem Modus sich die App befindet
    if(config('paypal.settings.mode') == 'live'){
        $this->client_id = config('paypal.credentials.live.client_id');
        $this->secret = config('paypal.credentials.live.secret');
        $this->plan_id = env('PAYPAL_LIVE_PLAN_ID', '');
    } else {
        $this->client_id = config('paypal.credentials.sandbox.client_id');
        $this->secret = config('paypal.credentials.sandbox.secret');
        $this->plan_id = env('PAYPAL_SANDBOX_PLAN_ID', '');
    }

    // Nun legst Du den Paypal API Context fest
    $oAuthToken = new OAuthTokenCredential($this->client_id, $this->secret)
    $this->apiContext = new ApiContext();
    $this->apiContext->setConfig(config('paypal.settings'));
}

Selbstverständlich kannst Du auch noch ein Key-Value Paar in Deine Paypal Konfiguration aufnehmen, um bspw. mehrere vordefinierte Pläne bereitzustellen. Nun erstellst Du die erste Methode, in der ein Vertrag mit der Paypal PHP SDK angelegt wird. Danach wird der Benutzer nach Paypal weitergeleitet:

<?php
public function paypal_redirect(){
    // Anlegen eines neuen Abonnements
    $agreement = new Agreement();
    $agreement->setName('myApplication - Abonnement')
      ->setDescription('Basisvertrag')
      ->setStartDate(CarbonCarbon::now()->addMinutes(5)->toIso8601String());

    // Nun wird dem Vertrag die zuvor generierte „billing plan“ ID zugewiesen
    $plan = new Plan();
    $plan->setId($this->plan_id);
    $agreement->setPlan($plan);

    // Kundendetails – Hier reicht die Bezahlmethode. Kann aber erweitert werden
    $payer = new Payer();
    $payer->setPaymentMethod('paypal');
    $agreement->setPayer($payer);

    try {
      // Nun kannst Du den Vertrag über die PHP SDK vorbereiten
      $agreement = $agreement->create($this->apiContext);

      // Nun wird noch die Bestätigungs-Url von Paypal ermittelt um den nutzer weiterzuleiten
      $approvalUrl = $agreement->getApprovalLink();

      return redirect($approvalUrl);
    } catch (PayPalExceptionPayPalConnectionException $ex) {
      echo $ex->getCode();
      echo $ex->getData();
      die($ex);
    } catch (Exception $ex) {
      die($ex);
    }

}

Also nächstes brauchst Du noch die Funktion auf die Paypal den Benutzer zurückleitet. An dieser Stelle bekommst Du von Paypal auch einen Token übergeben mit dessen Hilfe Du bei der Vertragserstellung erkennen kannst, ob der Benutzer mit dem Vertrag einverstanden ist:

public function paypal_return(Request $request){
    $token = $request->token;
    $agreement = new PayPalApiAgreement();

    try {
        // Jetzt kannst Du versuchen mit dem Paypal Token den Vertrag anzulegen
        $result = $agreement->execute($token, $this->apiContext);
        $user = Auth::user();
        $user->role = 'Abonnent';
        $user->paypal = 1;

        if(isset($result->id)){
            $user->paypal_agreement_id = $result->id;
        }

        $user->save();
        echo 'Ein neuer Abonnent wurde eingetragen!';

    } catch (PayPalExceptionPayPalConnectionException $ex) {
        echo 'Entweder hast Du die Bezahlung abgebrochen, oder Deine Sitzung ist abgelaufen.';
    }
}

Ist alles gut gelaufen wird Dir eine „agreement Id“ zurückgegeben und diese kannst Du im Benutzer speichern. Deine Benutzer können über die Url „http://myapplication.dev/subscribe/paypal“ nun ein Abonnement abschließen. Wie Du die Url schlussendlich integrierst ist Dir überlassen. Hier folgt noch ein Beispiel für die Integration über eine einfachen Link:

<a href="{{ url('subscribe/paypal') }}" class=“paypal-btn“>Abonnement anlegen</a>

Schritt 10 – Abfragen des Status eines Abonnements

Im letzten Schritt wollte ich Dir noch zeigen, wie Du schnell den Status eines Abonnements abfragen kannst, um bspw. zu erkennen, ob dieses noch aktiv ist. Deine Nutzer können diese ja auch einstellen. Zunächst ergänzt Du Deine Routen um folgenden Eintrag:

Route::get('/agreement-status', 'PaypalController@paypal_agreement_status');

Im Paypal Controller solltest Du nun noch den folgenden Namespace hinzufügen:

use PaypalApiAgreement;

Den Paypal Controller erweiterst Du nun um folgende Funktion:

public function paypal_agreement_status(Request $request){
    try {
        $user = Auth::user();
        $agreement = Agreement::get($user->paypal_agreement_id, $this->apiContext);

        if(isset($agreement->id)){
            $user->paypal_agreement_status = $agreement->state;
        }

        $user->save();
        echo sprintf('Das Abonnement „%s“ hat aktuell den Status „%s“.', $agreement->id, $agreement->state);

    } catch (PayPalExceptionPayPalConnectionException $ex) {
        echo 'Beim Abrufen des Abonnement-Status kam es zum Fehler.';
        echo $ex->getCode();
        echo $ex->getData();
        die($ex);
    }
 }

Dies ist ebenfalls nur eine Beispielfunktion, die Dir zeigen soll, wie einfach Du den Status abrufen kannst. Willst Du weitere Funktionen von Paypal in Deiner Anwendung integrieren, so wirf doch einen Blick in die Dokumentation. Paypal liefert in Deiner PHP SDK auch viele nützliche Beispiele an denen Du Dich bei der integration orientieren kannst Github – Paypal php sdk – Beispiel.

 

In diesem Artikel hast Du gelernt, wie Du die PHP SDK von Paypal in Laravel 5.5 integrierst. Du hast Composer eingesetzt um Laravel aufzusetzen und die PHP SDK zu integrieren. Weiterhin hast Du Projektkomponenten wie z.B. Controller und Migrationen mit dem Tool Artisan angelegt. Dein Paypal Controller wurde mit der PHP SDK verknüpft und Du hast mit Hilfe eines “billing plan” eine Möglichkeit geschaffen, um Abonnements einzurichten und deren Status abzufragen.

Solltest du Fragen oder Anregungen zum Thema haben, hinterlasse einfach ein Kommentar.