Erstellen Sie ein lizenzgesteuertes Update-System: Die License Manager-API

() translation by (you can also view the original English article)

Dies ist das zweite Tutorial in einer dreiteiligen Tutorialserie zum Erstellen eines lizenzgesteuerten WordPress-Plugins und eines Themes-Update-Systems.

Im ersten Teil der Serie haben wir ein WordPress-Plugin zum Speichern und Verwalten von Softwarelizenzen erstellt. In Teil drei werden wir ein WordPress-Theme erstellen, das den Lizenzmanager-Server verwendet, um nach Updates zu suchen und sie herunterzuladen.

In diesem Lernprogramm erstellen wir die Schnittstelle zwischen den beiden: Eine API mit zwei Aktionen, die von einer externen Site aus aufgerufen werden können, um Informationen zu einem Produkt und seiner Lizenz zu erhalten und das Produkt herunterzuladen.

Während Sie an dem Plugin arbeiten, lernen Sie folgende Themen kennen:

Erstellen einer API auf einem WordPress-Plugin.
Einstellungsseite erstellen.
Hochladen von Dateien zu Amazon Simple Storage Service (S3)
Verwenden des AWS SDK zum Erstellen von signierten URLs, mit denen private Dateien von S3 heruntergeladen werden können.

Wir werden das Plugin weiterhin auf den Code aufbauen, den wir in Teil 1 des Tutorials erstellt haben. Daher sollten Sie in der Lage sein, ein funktionsfähiges Plugin zu erstellen, indem Sie die Schritte ausführen. Wenn Sie das Lernprogramm mit dem Readymade-Code verfolgen möchten, checken Sie den Quellcode im Tuts + Github-Repository aus, das rechts verlinkt ist.

Lass uns anfangen.

Lizenzmanager-API erstellen

Eine API kann viele verschiedene Bedeutungen haben. In diesem Lernprogramm bedeutet dies eine Reihe von Aktionen (häufig als Methoden bezeichnet), die über eine HTTP-Verbindung aufgerufen werden können, um auf einen genau definierten, begrenzten Teil der Funktionalität der Anwendung zuzugreifen.

In Teil drei der Serie werden wir diese API in einem erstklassigen WordPress-Plugin oder Design verwenden, um die Gültigkeit der Lizenz zu prüfen und Updates herunterzuladen. Die API selbst setzt jedoch keine Einschränkungen. Die Anwendung, die die API verwendet, kann genauso gut ein Spiel sein, das vor dem Spielen mit einem Lizenzschlüssel aktiviert werden muss.

Auf unsere API können Sie über die URL https://<yoursite>/api/license-manager/v1/ zugreifen. Dabei ist Ihre Site die URL Ihrer WordPress-Site, auf der das WP License Manager-Plugin ausgeführt wird. Die API hat zwei Funktionen:

info: Gibt Informationen zum angeforderten Produkt zurück, wenn der angegebene Lizenzschlüssel gültig ist.
get: Gibt die herunterladbare Datei zurück, wenn der angegebene Lizenzschlüssel gültig ist.

Lass es uns bauen!

Schritt 1: Erstellen Sie eine Klasse für die API-Funktionalität

Bisher haben wir die vorhandenen Klassen aus der WordPress-Plugin-Boilerplate verwendet, aber jetzt, um die Dinge sauber zu halten, fügen wir eine neue Klasse zum Speichern der API-spezifischen Funktionalität hinzu.

Eine API ist ein öffentlicher Teil des Plugins, daher muss die neue Klasse in das public -Verzeichnis in der Plugin-Boilerplate wechseln. Rufen Sie die API-Klasse Wp_License_Manager_API auf und platzieren Sie sie in einer Datei namens class-wp-license-manager-api.php.

Machen Sie jetzt eine leere Klasse:

/**
 * The API handler for handling API requests from themes and plugins using
 * the license manager.
 *
 * @package    Wp_License_Manager
 * @subpackage Wp_License_Manager/public
 * @author     Jarkko Laine <jarkko@jarkkolaine.com>
 */
class Wp_License_Manager_API {

}

Verknüpfen Sie die neu erstellte Klasse mit Ihrer Wp_License_Manager_Public-Klasse, um sie bei Bedarf verfügbar zu machen. Fügen Sie zunächst ein Feld für die API-Klasse hinzu:

1	/**
2	* @var License_Manager_API The API handler
3	*/
4	private $api;

Dann initialisieren Sie es im Konstruktor (Zeile 11 ist der neue, alles andere ist bereits aus Teil 1 vorhanden):

/**
 * Initialize the class and set its properties.
 *
 * @var      string    $plugin_name       The name of the plugin.
 * @var      string    $version    The version of this plugin.
 */
public function __construct( $plugin_name, $version ) {
    $this->plugin_name = $plugin_name;
    $this->version = $version;

    $this->api = new Wp_License_Manager_API();  
}

Jetzt sind wir alle bereit, die API-Funktionalität zu erstellen.

Schritt 2: Definieren Sie Abfragevariablen für die API

Wie bereits erwähnt, erstellen wir zunächst ein spezielles URL-Format für den Zugriff auf die API. Auf diese Weise können wir die API-Aufrufe für andere Anforderungen an die Site trennen, ohne vom Rest der Inhalte der WordPress-Site verwirrt zu werden.

Standardmäßig (und unter der Haube) sind WordPress-URLs eine Kombination aus index.php und einer Reihe von Abfrageparametern. Beispiel: http://<yoursite>/?p=123 (index.php wird in der URL nicht angegeben.) aber da geht die Anfrage hin. Die meisten Sites verwenden - und wir werden auch - schönere Permalink-Einstellungen, um die URLs lesbarer zu machen. Dies ist jedoch nur eine Dekorationsebene über dieser Kernfunktionalität.

Um unsere API zu erstellen, müssen Sie zunächst eine benutzerdefinierte Abfragevariable __wp_license_api anstelle von p hinzufügen. Sobald dies funktioniert, fügen wir benutzerdefinierte Permalink-Einstellungen hinzu, um die API lesbarer zu machen.

Fügen Sie am Ende der Funktion define_public_hooks in der Klasse Wp_License_Manager die folgenden Zeilen hinzu, um einen Filter mit dem Hook query_vars zu verknüpfen:

1	// The external API setup
2	$this->loader->add_filter( 'query_vars', $plugin_public, 'add_api_query_vars' );

Fügen Sie dann die Funktion in der Klasse Wp_License_Manager_Public hinzu:

/**
 * Defines the query variables used by the API.
 *
 * @param $vars     array   Existing query variables from WordPress.
 * @return array    The $vars array appended with our new variables
 */
public function add_api_query_vars( $vars ) {
    // The parameter used for checking the action used
    $vars []= '__wp_license_api';

    // Additional parameters defined by the API requests
    $api_vars = $this->api->get_api_vars();

    return array_merge( $vars, $api_vars );
}

Diese Funktion fügt unsere Abfragevariablen zur Whitelist von WordPress hinzu, indem Sie sie dem von dem Filter übergebenen $vars-Array hinzufügen und das angehängte Array zurückgeben:

Zeile 9: Fügen Sie die Variable hinzu, um die API-Aktion anzugeben (und erkennen, dass die Anforderung tatsächlich für die API bestimmt ist), __wp_license_api

Zeile 12: Geben Sie der API-Klasse die Möglichkeit, zusätzliche Parameter hinzuzufügen, die von ihren Funktionen verwendet werden.

Zeile 14: Gibt das aktualisierte $vars-Array zurück.

Damit der Code funktioniert, müssen wir noch die Funktion get_api_vars erstellen:

/**
 * Returns a list of variables used by the API
 *
 * @return  array    An array of query variable names.
 */
public function get_api_vars() {
    return array( 'l',  'e', 'p' );
}

Da die API noch immer sehr einfach ist, habe ich mich dazu entschlossen, diese Funktion einfach zu gestalten und alle Parameter in ein Array aufzunehmen und zurückzugeben.

Schritt 3: Fangen Sie die API-Anforderungen ab

Wir haben jetzt unsere Abfragevariablen auf die weiße Liste gesetzt, aber sie tun noch nichts. Damit die Variablen etwas bewirken können, müssen Sie eine Funktionalität zum Erfassen der API-Anforderungen erstellen.

Dies kann mit der WordPress-Aktion parse_request durchgeführt werden.

Verknüpfen Sie in Wp_License_Managers define_public_hooks eine Funktion mit der Aktion:

1	$this->loader->add_action( 'parse_request', $plugin_public, 'sniff_api_requests' );

Nun werden alle zukünftigen Anforderungen an diese WordPress-Installation diese Funktion durchlaufen, bevor sie an die eigenen Anforderungsbehandlungsfunktionen von WordPress weitergeleitet werden. Das bedeutet, dass wir die Handlerfunktion leichtgewichtig halten müssen: Überprüfen Sie, ob __wp_license_api festgelegt wurde, und wenn nicht, kehren Sie schnell zurück und lassen Sie WordPress fortfahren. Wenn ja, ist es in Ordnung, etwas komplexeres Handling durchzuführen - dies ist unsere Bitte und wir werden es erledigen.

Die Funktion sniff_api_requests geht in Wp_License_Manager_Public:

/**
 * A sniffer function that looks for API calls and passes them to our API handler.
 */
public function sniff_api_requests() {
    global $wp;
    if ( isset( $wp->query_vars['__wp_license_api'] ) ) {
        $action = $wp->query_vars['__wp_license_api'];
        $this->api->handle_request( $action, $wp->query_vars );

        exit;
    }
}

Zeile 6: Prüfen Sie, ob die API-Aktionsabfragevariable vorhanden ist. Wenn ja, ist dies ein Aufruf an diese API.

Zeilen 7-8: Übergeben Sie die Anforderung an die zu behandelnde Funktion handle_request der API-Klasse. Als nächstes erstellen wir diese Funktion.

Zeile 10: Stoppen Sie die Ausführung der WordPress-Anfrage, sobald wir den API-Aufruf bearbeitet haben. Dies ist wichtig, da sonst die Ausführung mit WordPress fortgesetzt wird und nach der API-Ausgabe eine 404-Fehlerseite angezeigt wird.

Als nächstes fügen wir die Funktion handle_request hinzu.

Im Moment ist dies eine reine Implementierung, mit der wir prüfen können, ob unser Framework funktioniert. Ich habe Platzhalter für die zwei Aktionen eingefügt, die wir in diesem Lernprogramm erstellen werden, und eine Standardantwort, die gesendet wird, wenn ein Benutzer eine API-Aktion verwendet, die wir nicht unterstützen.

/**
 * The handler function that receives the API calls and passes them on to the
 * proper handlers.
 *
 * @param $action   string  The name of the action
 * @param $params   array   Request parameters
 */
public function handle_request( $action, $params ) {
    switch ( $action ) {
        case 'info':
            break;

        case 'get':
            break;

        default:
            $response = $this->error_response( 'No such API action' );
            break;
    }

    $this->send_response( $response );
}

Zeile 17: $response ist ein Array mit den Informationen, die an die Anwendung übergeben werden sollen, die die API aufruft.

Zeile 21: Drucken Sie die Antwort als JSON-codierte Zeichenfolge aus.

Damit die Funktion funktioniert, müssen wir noch die von ihr verwendeten Hilfsfunktionen hinzufügen: send_response und error_response.

Zuerst send_response:

/**
 * Prints out the JSON response for an API call.
 *
 * @param $response array   The response as associative array.
 */
private function send_response( $response ) {
    echo json_encode( $response );
}

Dann error_response. Diese Funktion erstellt ein Array mit der angegebenen Fehlermeldung. Durch die Verwendung einer Funktion zum Generieren des Arrays können wir sicherstellen, dass alle Fehlermeldungen auf dieselbe Weise formatiert werden, und die Formatierung bei Bedarf später im Lebenszyklus des Plugins leicht ändern.

Fürs Erste habe ich mich für eine Basisversion entschieden, die nur eine Fehlermeldung innerhalb des Arrays enthält:

/**
 * Generates and returns a simple error response. Used to make sure every error
 * message uses same formatting.
 *
 * @param $msg      string  The message to be included in the error response.
 * @return array    The error response as an array that can be passed to send_response.
 */
private function error_response( $msg ) {
    return array( 'error' => $msg );
}

Jetzt haben Sie die Struktur erstellt, in der wir die API-Aktionen erstellen können. Rufen Sie zum Testen eine nicht vorhandene API-Aktion auf, beispielsweise http://<yoursite>/?__wp_license_api=dummy-action in einem Browserfenster.

Sie sollten so etwas sehen:

Selbst wenn die API immer noch nur eine Fehlernachricht zurückgibt, zeigt der Test, dass die Anforderung an die korrekte Handlerfunktion weitergeleitet wird und nicht mit dem Rest des WordPress-Ablaufs verwechselt wird. So wie wir es wollten.

Bevor wir nun mit dem Hinzufügen von API-Funktionen beginnen, sollten wir uns die API-URL ein wenig leichter merken.

Schritt 4: Erstellen Sie ein benutzerdefiniertes URL-Format für die API

Während http://<yoursite>/?__wp_license_api=<action> funktioniert, ist es nicht sehr hübsch, und es macht meiner Meinung nach auch ein wenig zu viel von den Internen der API-Implementierung preis. Erstellen wir also ein schöneres URL-Format, das stattdessen verwendet werden soll.

Zur Erinnerung an den Anfang dieses Abschnitts ist hier die URL, die wir verwenden werden:http://<yoursite>/api/license-manager/v1/

Ich habe der API-URL v1 hinzugefügt, nur für den Fall, dass wir irgendwann mehrere verschiedene Versionen der API unterstützen werden. Da die Versionsinformationen von Anfang an vorhanden sind, ist das Hinzufügen neuer Versionen einfacher.

Um "hübsche" URLs wie diese zu erstellen, setzen Sie die Option Permalinks in den WordPress-Einstellungen auf einen anderen Wert als den Standardwert (alle anderen Optionen außer "Default" sind in Ordnung).

Fügen Sie dann einen Filter hinzu, um eine neue Umschreibregel zu erstellen. Fügen Sie die Filterregistrierung zu define_public_hooks von Wp_License_Manager hinzu:

1	$this->loader->add_action( 'init', $plugin_public, 'add_api_endpoint_rules' );

Dann erstellen Sie die Funktion (in Wp_License_Manager_Public):

/**
 * The permalink structure definition for API calls.
 */
public function add_api_endpoint_rules() {
    add_rewrite_rule( 'api/license-manager/v1/(info|get)/?',
        'index.php?__wp_license_api=$matches[1]', 'top' );

    // If this was the first time, flush rules
    if ( get_option( 'wp-license-manager-rewrite-rules-version' ) != '1.1' ) {
        flush_rewrite_rules();
        update_option( 'wp-license-manager-rewrite-rules-version', '1.1' );
    }
}

Zeile 5: Definieren Sie mithilfe eines regulären Ausdrucks eine neue URL-Umschreibungsregel, um die Anforderungen entsprechend dem von uns vorgestellten Gedanken an die im vorherigen Schritt verwendete URL zu senden. (info|get) definiert die API-Methoden, die die API akzeptieren soll.

Zeilen 9-12: Speichern Sie die Umschreiberegeln, um sie zu aktivieren. flush_rewrite_rules ist ein aufwändiger Aufruf von Ressourcen, daher habe ich eine Überprüfung hinzugefügt, um sicherzustellen, dass die Spülung nur durchgeführt wird, wenn die Regeln geändert wurden.

Wenn dieser Schritt abgeschlossen ist, werden alle an http://<yoursite>/api/license-manager/v1/<action> gesendeten Anforderungen in eine Anfrage an http://<yoursite>?__wp_license_api=<action>umgewandelt . Testen Sie dies mit derselben Dummy-Aktion aus dem vorherigen Schritt - Sie sollten jetzt das gleiche Ergebnis mit beiden URLs erhalten.

Das API-Framework ist jetzt vorhanden, und wir können damit beginnen, Funktionalität hinzuzufügen.

Schritt 5: Erstellen Sie die Funktionalität zum Überprüfen von Lizenzen

Beide API-Aktionen, die wir in diesem Lernprogramm erstellen, beginnen mit der Überprüfung der Benutzerlizenz.

Zuerst habe ich den Lizenzbestätigungscode für beide separat geschrieben, aber als ich die beiden Handler sah, fiel mir schnell auf, dass sie genau gleich waren. Für mich ist dies ein gutes Zeichen, dass es Zeit ist, Refactoring durchzuführen.

Um Zeit zu sparen, überspringen wir den Schritt, in dem wir denselben Code zweimal schreiben, und fahren stattdessen direkt mit der endgültigen Version fort und fügen den allgemeinen Code in eine eigene Funktion ein.

Erstellen Sie in Wp_License_Manager_API eine Funktion mit dem Namen verify_license_and_execute. Diese Funktion wird als zusätzlicher Schritt zwischen der zuvor erstellten Funktion und der tatsächlichen Bearbeitung der Anforderungen verwendet.

/**
 * Checks the parameters and verifies the license, then forwards the request to the
 * actual API request handlers.
 *
 * @param $action_function  callable    The function (or array with class and function) to call
 * @param $params           array       The WordPress request parameters.
 * @return array            API response.
 */
private function verify_license_and_execute( $action_function, $params ) {
    if ( ! isset( $params['p'] ) || ! isset( $params['e'] ) || ! isset( $params['l'] ) ) {
        return $this->error_response( 'Invalid request' );
    }

    $product_id = $params['p'];
    $email = $params['e'];
    $license_key = $params['l'];

    // Find product
    $posts = get_posts(
        array (
            'name' => $product_id,
            'post_type' => 'wplm_product',
            'post_status' => 'publish',
            'numberposts' => 1
        )
    );

    if ( ! isset( $posts[0] ) ) {
        return $this->error_response( 'Product not found.' );
    }

    // Verify license
    if ( ! $this->verify_license( $posts[0]->ID, $email, $license_key ) ) {
        return $this->error_response( 'Invalid license or license expired.' );
    }

    // Call the handler function
    return call_user_func_array( $action_function, array( $posts[0], $product_id, $email, $license_key ) );
}

Zeilen 10-12: Stellen Sie sicher, dass alle lizenzrelevanten Parameter vorhanden sind. p ist der Slug des Produkts, e ist die E-Mail-Adresse des Benutzers und l ist der Lizenzschlüssel.

Zeilen 14-16: Parameter sammeln und desinfizieren.

Zeilen 19-26: Suchen Sie den Beitrag, der der angegebenen Produkt-ID entspricht. Wie bereits erwähnt, handelt es sich bei der Produkt-ID eigentlich um den Post Slug des Produkts, damit der Benutzer den richtigen Wert für das Produkt leichter erkennen kann.

Zeilen 28-30: Wenn das Produkt nicht gefunden wird, einen Fehler zurückgeben.

Zeilen 33-35: Führen Sie die eigentliche Lizenzschlüsselüberprüfung durch. Als nächstes erstellen wir diese Funktion.

Zeile 38: Rufen Sie die für die Behandlung der API-Aktion verantwortliche Funktion auf. Als Entwicklungsidee für die Zukunft wäre dies ein großartiger Ort für einen Filter, den andere Plugins verwenden könnten, um die Handlerfunktion bei Bedarf zu ersetzen.

Als Nächstes fügen Sie die Funktion zum Überprüfen der Lizenz hinzu:

/**
 * Checks whether a license with the given parameters exists and is still valid.
 *
 * @param $product_id   int     The numeric ID of the product.
 * @param $email        string  The email address attached to the license.
 * @param $license_key  string  The license key.
 * @return bool                 true if license is valid. Otherwise false.
 */
private function verify_license( $product_id, $email, $license_key ) {
    $license = $this->find_license( $product_id, $email, $license_key );
    if ( ! $license ) {
        return false;
    }

    $valid_until = strtotime( $license['valid_until'] );
    if ( $license['valid_until'] != '0000-00-00 00:00:00' && time() > $valid_until ) {
        return false;
    }

    return true;
}

Zeilen 10-13: Suchen Sie die Lizenz anhand der gesendeten Parameter aus der Datenbank (wir fügen diese Funktion als Nächstes hinzu). Wenn die Lizenz nicht gefunden wird, kann sie nicht gültig sein, sodass wir false zurückgeben können.

Zeilen 15-18: Wenn die Lizenz vorhanden ist, prüfen Sie, ob sie abgelaufen ist. Im ersten Teil des Tutorials haben wir definiert, dass 0000-00-00 00:00:00 für eine Lizenz verwendet wird, die niemals abläuft.

Zeile 20: Alle Prüfungen bestanden, die Lizenz ist gültig.

Um den Lizenzvalidierungscode abzuschließen, benötigen wir schließlich die Funktion zum Abrufen einer Lizenz aus der Datenbank.

Fügen Sie die Funktion find_license hinzu:

/**
 * Looks up a license that matches the given parameters.
 *
 * @param $product_id   int     The numeric ID of the product.
 * @param $email        string  The email address attached to the license.
 * @param $license_key  string  The license key
 * @return mixed                The license data if found. Otherwise false.
 */
private function find_license( $product_id, $email, $license_key ) {
    global $wpdb;
    $table_name = $wpdb->prefix . 'product_licenses';

    $licenses = $wpdb->get_results(
        $wpdb->prepare( "SELECT * FROM $table_name WHERE product_id = %d AND email = '%s' AND license_key = '%s'",
            $product_id, $email, $license_key ), ARRAY_A );

    if ( count( $licenses ) > 0 ) {
        return $licenses[0];
    }

    return false;
}

In dieser Funktion führen wir eine SQL-Abfrage aus, um nach einer Lizenz mit den genauen Parametern, Produkt-ID, E-Mail und Lizenzschlüssel zu suchen. Auf diese Weise müssen wir die Antwort nicht zusätzlich analysieren, als zu sehen, ob ein Ergebnis vorliegt oder nicht.

Wenn eine Lizenz gefunden wird, gibt die Funktion diese zurück. Andernfalls wird false zurückgegeben.

Schritt 6: Fügen Sie die Produktinformations-API-Aktion hinzu

Als Nächstes fügen wir die erste der beiden Aktionen hinzu, info. Geben Sie in der Funktion handle_request, die wir vor einiger Zeit erstellt haben, den Fallzweig für die Aktion ein:

1	case 'info':
2	$response = $this->verify_license_and_execute( array( $this, 'product_info' ), $params );
3	break;

Die Zeile, die wir hinzugefügt haben, ruft unsere Funktion verify_license_and_execute mit zwei Parametern auf:

Der erste Parameter sollte Ihnen aus den WordPress-Aktionen und -Filtern, die wir während der gesamten Lernreihe erstellt haben, bekannt sein. Sie übergibt den Namen der Funktion, mit der die Aktion ausgeführt werden soll, sobald die Lizenz überprüft wurde. Da sich die Funktion innerhalb einer Klasse befindet, müssen wir ein Array übergeben, nicht nur den Namen der Funktion.
Der zweite Parameter ist die Liste aller an WordPress gesendeten Anforderungsparameter.

Wir haben uns schon angesehen, was in verify_license_and_execute passiert, also fügen wir die Funktion product_info hinzu. Diese Funktion sammelt Informationen zum Produkt und gibt sie als Array zurück.

Wie Sie sich wahrscheinlich aus Teil 1 des Lernprogramms erinnern, werden Produkte im Lizenzmanager-Plugin als benutzerdefinierter Beitragstyp mit einer Meta-Box zum Eingeben zusätzlicher Produktinformationen gespeichert. In dieser Funktion greifen wir auf diese Daten zu und füllen das $response-Array mit Informationen zum angeforderten Produkt:

/**
 * The handler for the "info" request. Checks the user's license information and
 * returns information about the product (latest version, name, update url).
 *
 * @param   $product        WP_Post   The product object
 * @param   $product_id     string    The product id (slug)
 * @param   $email          string    The email address associated with the license
 * @param   $license_key    string  The license key associated with the license
 *
 * @return  array           The API response as an array.
 */
private function product_info( $product, $product_id, $email, $license_key ) {
    // Collect all the metadata we have and return it to the caller
    $meta = get_post_meta( $product->ID, 'wp_license_manager_product_meta', true );

    $version = isset( $meta['version'] ) ? $meta['version'] : '';        
    $tested = isset( $meta['tested'] ) ? $meta['tested'] : '';
    $last_updated = isset( $meta['updated'] ) ? $meta['updated'] : '';
    $author = isset( $meta['author'] ) ? $meta['author'] : '';
    $banner_low = isset( $meta['banner_low'] ) ? $meta['banner_low'] : '';
    $banner_high = isset( $meta['banner_high'] ) ? $meta['banner_high'] : '';

    return array(
        'name' => $product->post_title,
        'description' => $product->post_content,
        'version' => $version,
        'tested' => $tested,
        'author' => $author,
        'last_updated' => $last_updated,
        'banner_low' => $banner_low,
        'banner_high' => $banner_high,
        "package_url" => home_url( '/api/license-manager/v1/get?p=' . $product_id . '&e=' . $email . '&l=' . urlencode( $license_key ) ),
        "description_url" => get_permalink( $product->ID ) . '#v=' . $version
    );
}

Zeile 14: Produktinformationen aus den Post-Metadaten abrufen.

Zeilen 16-21: Sammeln Sie die Daten aus den Metadatenfeldern.

Zeilen 23-34: Erstellen Sie die Antwort. Meistens geht es nur darum, die Daten aus den Zeilen 16-21 in das Array einzufügen. Eine Zeile, Zeile 32, verdient jedoch mehr Aufmerksamkeit.

Dies ist für das WordPress-Aktualisierungssystem, das wir im nächsten Tutorial der Serie verwenden werden. Um diesen Schritt zu vereinfachen, gibt die info-Aktion eine URL zurück, die auf die andere get-Aktion der API zeigt, mit allen erforderlichen Parametern.

Schritt 7: Testen Sie die API-Aktion

Sie haben jetzt die erste unserer beiden API-Funktionen erstellt. Wenn Sie möchten, können Sie die Funktionalität testen, indem Sie die API-Methode in einem Webbrowser aufrufen. Stellen Sie nur sicher, dass die Daten ordnungsgemäß eingerichtet sind, bevor Sie den Anruf tätigen: Es muss ein Produkt und eine Lizenz im System vorhanden sein, damit die API-Aktion funktioniert.

Ein weiterer Haken ist, dass Sie die E-Mail- und Lizenzschlüssel-Parameter vor dem Platzieren in die URL kodieren müssen, da sie Sonderzeichen enthalten.

Die Ausgabe sieht in etwa so aus, je nachdem, was Sie als Produktdaten gespeichert haben:

Speichern von Dateien in Amazon S3

Nach Abschluss der ersten Hälfte der API ist es an der Zeit, die zweite API-Funktion get zu untersuchen. Diese API-Funktion überprüft den Lizenzschlüssel auf dieselbe Weise wie bei info und gibt dann die herunterladbare Datei zurück.

Damit die API-Aktion sinnvoll ist, ist es wichtig, dass auf den Download nicht ohne einen gültigen Lizenzschlüssel zugegriffen werden kann, indem einfach die API umgangen wird und die Datei direkt aufgerufen wird. Amazons Simple Storage Service (S3) bietet diese Funktionalität einfach und kostengünstig (für die meisten Benutzer fast kostenlos) und macht den Download zudem zuverlässig.

In den nächsten Schritten wird zunächst beschrieben, wie Sie die Dateien mithilfe des Online-Dashboards von AWS (Amazon Web Services) in Amazon S3 hochladen. Sobald die Datei hochgeladen wurde, fügen wir die API-Funktionalität zum Herunterladen hinzu.

Wenn Sie bereits Amazon S3 verwenden und sich damit auskennen, können Sie direkt mit dem nächsten Abschnitt fortfahren und die get-Aktion implementieren. Wenn Sie S3 noch nicht kennen, lesen Sie weiter.

Schritt 1: Erstellen Sie ein Konto

Das Erstellen eines AWS-Kontos ist gut dokumentiert, hat jedoch viele Schritte.

Gehen Sie zuerst zu aws.amazon.com und klicken Sie oben rechts auf "Anmelden".

Auf dem folgenden Bildschirm haben Sie die Möglichkeit, ein neues Amazon-Konto zu erstellen oder ein vorhandenes Konto zu verwenden, das Sie für andere Amazon-Dienste verwendet haben (beispielsweise den Online-Shop selbst):

Sie haben die Wahl: Wenn Sie sich für die Erstellung eines neuen Kontos entscheiden, wird dies als Nächstes geschehen. Wenn Sie Ihr vorhandenes Konto verwenden, springt der Ablauf direkt in den fünf Schritte des Einrichtens Ihres AWS-Kontos. Während der Registrierung werden Sie aufgefordert, Ihre Kreditkartendaten einzugeben. Bei den meisten Verwendungszwecken müssen Sie sich nicht um den Preis kümmern.

Nachdem Sie Ihre Kreditkarteninformationen eingegeben haben, bevor Ihr Konto akzeptiert wird, müssen Sie Ihre Telefonnummer bestätigen. Amazon ruft automatisch Ihre Telefonnummer an und fordert Sie auf, den auf Ihrem Bildschirm angezeigten vierstelligen Code einzugeben. Als ich es beim Versuch dieses Tutorials erneut versuchte, hatte ich Schwierigkeiten, den Code mit der iPhone-Tastatur einzugeben. Es war jedoch perfekt, die Zahlen einzeln laut auszusprechen.

Der letzte Schritt ist die Auswahl eines Support-Plans. Ich schlage vor, Sie wählen die kostenlose Option für jetzt. Es gibt wirklich keine großen Unterstützungsanforderungen für S3, und Sie können die Option noch einmal überdenken, wenn Sie sich für die erweiterten Funktionen entscheiden.

Nachdem Sie Ihr Konto erstellt und aktiviert haben, fügen Sie eine Datei hinzu.

Schritt 2: Bucket erstellen

Starten Sie die AWS Management Console und wählen Sie im Optionsbildschirm S3 aus:

Der AWS-Administrator bietet viele Funktionen, aber Sie können den Rest vorerst ignorieren (dies sind fortgeschrittene Dinge, die die meisten WordPress-Entwickler nie brauchen werden - ich verwende im Moment nur S3 und EC2).

Nun, da Sie sich in der S3-Administrationskonsole befinden, erstellen Sie zunächst einen Bucket. Ein Bucket ist ein Container der obersten Ebene für Ihre S3-Dateien, der Ordner und Dateien enthalten kann. So beschreibt die AWS-Dokumentation das Konzept:

Jedes in Amazon S3 gespeicherte Objekt befindet sich in einem Bucket. Sie können Buckets verwenden, um verwandte Objekte auf dieselbe Weise zu gruppieren, wie Sie ein Verzeichnis verwenden, um Dateien in einem Dateisystem zu gruppieren. Buckets verfügen über Eigenschaften wie Zugriffsberechtigungen und den Status der Versionierung. Sie können den Bereich angeben, in dem sie sich befinden sollen.

Geben Sie Ihrem Bucket einen Namen, der aus Kleinbuchstaben (a-z), Zahlen, Bindestrichen und Punkten besteht (nähere Angaben finden Sie in der Dokumentation) und klicken Sie auf "Erstellen".

Wenn Sie möchten, können Sie auch eine Region auswählen, in der Ihre Dateien gespeichert werden sollen. Es ist jedoch vollkommen in Ordnung, die Einstellung auf die Standardeinstellung zu belassen.

Nachdem Sie den Bucket erstellt haben, wird eine Dateibrowseransicht mit dem erstellten Bucket angezeigt:

In diesem Bildschirm können Sie beliebig viele neue Buckets erstellen. Fürs Erste reicht es. Klicken Sie auf den Namen des Buckets, um Dateien hinzuzufügen.

Schritt 3: Datei hochladen

Der soeben erstellte Bucket enthält die Downloads für Ihre Lizenzmanager-Installation. Wir werden die herunterladbaren Designs und Plugins erst im dritten und letzten Teil des Tutorials erstellen. Erstellen Sie zum Testen einfach eine ZIP-Datei mit etwas (zum Beispiel einer Textdatei).

Klicken Sie auf die Schaltfläche Hochladen in der oberen linken Ecke des S3-Verwaltungsbildschirms. Ein Upload-Bildschirm wird angezeigt:

Wählen Sie Add Files, um die hochzuladenden Dateien auszuwählen. Klicken Sie dann auf Start Upload.

Wir könnten Set Details verwenden, um die Dateiberechtigungen festzulegen. Da wir den Download jedoch nicht öffentlich verfügbar machen möchten, sind die Standardoptionen genau das, was wir wollen.

Nachdem die Datei hochgeladen wurde, wird sie in Ihrem Bucket angezeigt:

Schließen Sie das Transferfenster, indem Sie auf das Kreuz in der oberen rechten Ecke klicken. Wählen Sie dann die Datei aus und wählen Sie im oberen rechten Menü die Option Properties :

In diesem Bildschirm können Sie weiterhin die Berechtigungen der Datei und andere Einstellungen anpassen. In den Informationen finden Sie auch die URL der Datei. Kopieren Sie den Link und öffnen Sie ihn in einem Browser, um zu testen, was passiert, wenn Sie versuchen, die Datei herunterzuladen.

Wenn alles korrekt eingerichtet ist, können Sie das nicht tun: Selbst wenn ein zufälliger Besucher die genaue URL Ihrer Downloaddatei kannte, kann er sie nicht herunterladen, indem er die Lizenzprüfung im API-Aufruf überspringt.

Wenn Sie einen Fehler wie diesen sehen, ist alles richtig eingerichtet und Sie können mit dem Erstellen des Codes zum Herunterladen dieser Datei beginnen:

Als letzten Schritt vor der weiteren Codierung erstellen Sie ein Produkt in WordPress mithilfe unseres Lizenzmanager-Plugins (oder aktualisieren ein vorhandenes) und fügen die Informationen der Downloaddatei hinzu:

Download von S3 bereitstellen

Nachdem Sie nun eine Datei erfolgreich auf Amazon S3 hochgeladen haben, geben Sie der Lizenzmanager-API die Datei zurück, wenn Sie dazu aufgefordert werden. Dies ist jedoch nur möglich, wenn die Lizenz des Benutzers gültig ist.

Dazu füllen wir den API-Aktionsplatzhalter aus, den wir unserer API-Behandlungsfunktion handle_request zuvor in diesem Lernprogramm hinzugefügt haben. Die Aktion überprüft zunächst die Lizenz mit verify_license_and_execute und erstellt dann mithilfe der offiziellen AWS-Bibliothek von Amazon einen signierten Download-Link zur herunterladbaren Datei des Produkts.

Schritt 1: Laden Sie die AWS Library herunter und fügen Sie sie ein

Laden Sie zunächst das AWS SDK für PHP von Amazon herunter.

Es gibt viele Möglichkeiten, das SDK in Ihr Projekt einzubeziehen. Ich empfehle Ihnen jedoch, den zip-Download in diesem Projekt zu verwenden, auch wenn es bereits ein wenig altmodisch ist: Das SDK enthält Funktionen zur Verwendung aller AWS-Funktionen. Es gibt viele davon - und wir verwenden nur einen, S3. Wenn Sie die ZIP-Version manuell herunterladen und in Ihr Projekt einfügen, haben Sie die Möglichkeit, alle zusätzlichen Dateien zu entfernen, die nur den Speicherplatz des Plugins beanspruchen.

Nachdem Sie das AWS SDK heruntergeladen haben, erstellen Sie ein Verzeichnis mit dem Namen lib im Verzeichnis wp-license-manager. Erstellen Sie darin ein Verzeichnis namens aws, das den Inhalt des ZIP-Pakets des SDK enthält.

Wenn Sie möchten, können Sie jetzt den Inhalt des Verzeichnisses zuschneiden und nur die Verzeichnisse Common und S3 in Aws belassen. Wenn die Größe des Plugins kein Problem ist, können Sie diesen Schritt genauso gut überspringen und das SDK so belassen, wie es ist.

Verbinden Sie als Nächstes das AWS SDK mit dem WP License Manager-Plugin auf Codeebene.

Das SDK verwendet Namespaces, eine PHP-Funktion, die nur in PHP 5.3 hinzugefügt wurde. Die offizielle PHP-Anforderung für WordPress ist 5.2.6. Daher kann das SDK nicht für alle WordPress-Benutzer verwendet werden.

Um diese Einschränkung zu umgehen, können Sie eine S3-Bibliothek eines Drittanbieters verwenden oder selbst eine schreiben. Da jedoch die Verwendung des offiziellen SDK generell der empfohlene Weg ist, gehen wir diesmal diesen Weg. In der im WordPress-Plugin-Repository veröffentlichten Version des Plugins habe ich sowohl die AWS SDK-Version als auch eine Fallback-Version mit dieser eigenständigen S3-Bibliothek enthalten. Das Plugin wählt die richtige Version zur Laufzeit aus, basierend auf der PHP-Version des Systems, auf dem das Plugin ausgeführt wird.

In diesem Lernprogramm werden wir jedoch die Dinge ein wenig einfacher halten und nur eine Version des AWS SDK haben.

Erstellen Sie eine neue Klasse, Wp_License_Manager_S3, und platzieren Sie sie im Include-Verzeichnis des Plugins:

<?php
/**
 * A wrapper for our Amazon S3 API actions.
 *
 * @package    Wp_License_Manager
 * @subpackage Wp_License_Manager/includes
 * @author     Jarkko Laine <jarkko@jarkkolaine.com>
 */
class Wp_License_Manager_S3 {

}

Fügen Sie der Klasse Wp_License_Manager-Funktion load_dependencies folgende Zeilen hinzu, um die Klasse in das Projekt aufzunehmen

/**
 * A wrapper class for our Amazon S3 connectivity.
 */
require_once plugin_dir_path( dirname( __FILE__ ) ) . 'includes/class-wp-license-manager-s3.php';
require_once plugin_dir_path( dirname( __FILE__ ) ) . 'lib/aws/aws-autoloader.php';

Die erste Zeile enthält die oben erstellte Wrapper-Klasse, und die zweite Klasse enthält den Autoloader des AWS SDK, einen Code, der für die erforderliche Anforderung der SDK-Quelldateien verantwortlich ist.

Schritt 2: Erstellen Sie die Funktion zum Generieren des Downloadlinks

Fügen Sie in der soeben erstellten Klasse Wp_License_Manager_S3 die folgende Funktion zum Generieren eines signierten Download-Links hinzu, der zum Herunterladen der geschützten Datei von Amazon S3 verwendet werden kann:

/**
 * Returns a signed Amazon S3 download URL.
 *
 * @param $bucket       string  Bucket name
 * @param $file_name    string  File name (URI)
 * @return string       The signed download URL
 */
public static function get_s3_url( $bucket, $file_name ) {
    $options = get_option( 'wp-license-manager-settings' );

    $s3_client = Aws\S3\S3Client::factory(
        array(
            'key'    => $options['aws_key'],
            'secret' => $options['aws_secret']
        )
    );

    return $s3_client->getObjectUrl( $bucket, $file_name, '+10 minutes' );
}

Gehen wir die Funktion durch, um zu sehen, was die ID macht:

Zeilen 11-16: Erstellen Sie eine Amazon S3-Clientklasseninstanz zum Erstellen des Download-Links. Das SDK erfordert AWS-Sicherheitsnachweise, die in WordPress-Optionen gespeichert werden. Dazu wird ein Einstellungsbildschirm verwendet, den wir im nächsten Schritt erstellen.

Zeile 18: Verwenden Sie das SDK, um einen Download-Link für den angegebenen Bucket und Dateinamen zu generieren. Der Download-Link ist ab diesem Moment für 10 Minuten gültig, sodass der Benutzer genügend Zeit hat, um den Download zu starten.

Schritt 3: Erstellen Sie eine Einstellungsseite für AWS-Einstellungen

Wie Sie im vorherigen Schritt bemerkt haben, müssen Sie einen AWS-API-Schlüssel und ein Geheimnis in den WordPress-Optionen speichern, damit das Plugin für die Verwendung mit verschiedenen AWS-Konten konfiguriert werden kann.

Dazu verwenden wir die Einstellungs-API. Das Erstellen einer Einstellungsseite mithilfe der Einstellungs-API besteht aus drei Schritten: Initialisieren der Einstellungsfelder, Hinzufügen der Einstellungsseite und Definieren von Funktionen zum Rendern der verschiedenen Teile der Einstellungsseite.

Alles beginnt mit dem Hinzufügen von zwei Aktionen, einer zu admin_init und einer zu admin_menu:

1	// Plugin settings menu$this->loader->add_action( 'admin_init', $plugin_admin, 'add_plugin_settings_fields');$this->loader->add_action( 'admin_menu', $plugin_admin, 'add_plugin_settings_page');

Nachdem Sie nun die Aktionen hinzugefügt haben, erstellen Sie die Funktionen, um sie zu handhaben. Beide müssen zur Klasse Wp_License_Manager_Admin hinzugefügt werden.

Fügen Sie zuerst die Funktion add_plugin_settings_fields hinzu, die einen Einstellungsabschnitt initialisiert, und dann zwei Einstellungsfelder, um darin zu gelangen:

/**
 * Creates the settings fields for the plugin options page.
 */
public function add_plugin_settings_fields() {
    $settings_group_id = 'wp-license-manager-settings-group';
    $aws_settings_section_id = 'wp-license-manager-settings-section-aws';
    $settings_field_id = 'wp-license-manager-settings';

    register_setting( $settings_group_id, $settings_field_id );

    add_settings_section(
        $aws_settings_section_id,
        __( 'Amazon Web Services', $this->plugin_name ),
        array( $this, 'render_aws_settings_section' ),
        $settings_group_id
    );

    add_settings_field(
        'aws-key',
        __( 'AWS public key', $this->plugin_name ),
        array( $this, 'render_aws_key_settings_field' ),
        $settings_group_id,
        $aws_settings_section_id
    );

    add_settings_field(
        'aws-secret',
        __( 'AWS secret', $this->plugin_name ),
        array( $this, 'render_aws_secret_settings_field' ),
        $settings_group_id,
        $aws_settings_section_id
    );
}

Zeilen 5-7: Initialisieren Sie drei Variablen mit den Namen des Einstellungsfelds und den Abschnittsnamen. Dies hilft uns sicherzustellen, dass wir keine Tippfehler einfügen ...

Zeile 9: Registrieren Sie das Einstellungselement 'wp-license-manager-settings'. Es wird ein Array sein, in dem die beiden Einstellungen aws-key und aws-secret gespeichert werden.

Zeilen 11-16: Fügen Sie den Einstellungsabschnitt hinzu, der beide Einstellungsfelder enthält.

Zeilen 18-32: Fügen Sie unsere beiden Einstellungsfelder (aws-key und aws-secret) hinzu und platzieren Sie sie in dem Einstellungsbereich, der in den Zeilen 11-16 erstellt wurde.

Fügen Sie nun die zweite Funktion add_plugin_settings_page hinzu. Diese Funktion erstellt die Einstellungsseite als untergeordnetes Element des Hauptmenüs mit der Funktion add_options_page.

/**
 * Adds an options page for plugin settings.
 */
public function add_plugin_settings_page() {
    add_options_page(
        __( 'License Manager', $this->plugin_name ),
        __( 'License Manager Settings', $this->plugin_name ),
        'manage_options',
        'wp-license-settings',
        array( $this, 'render_settings_page' )
    );
}

Für jedes der Elemente in den Einstellungen-API-Funktionen (Einstellungsseite, Einstellungsbereich und beide Einstellungsfelder) wird eine Rendering-Funktion als Parameter verwendet.

Um die Einrichtung der Einstellungsseite abzuschließen, erstellen Sie diese Anzeigefunktionen:

/**
 * Renders the plugin's options page.
 */
public function render_settings_page() {
    $settings_group_id = 'wp-license-manager-settings-group';
    require plugin_dir_path( dirname( __FILE__ ) ) . 'admin/partials/settings_page.php';
}

/**
 * Renders the description for the AWS settings section.
 */
public function render_aws_settings_section() {
    // We use a partial here to make it easier to add more complex instructions
    require plugin_dir_path( dirname( __FILE__ ) ) . 'admin/partials/aws_settings_group_instructions.php';
}

/**
 * Renders the settings field for the AWS key.
 */
public function render_aws_key_settings_field() {
    $settings_field_id = 'wp-license-manager-settings';
    $options = get_option( $settings_field_id );
    ?>
        <input type='text' name='<?php echo $settings_field_id; ?>[aws_key]' value='<?php echo $options['aws_key']; ?>' class='regular-text'>
    <?php
}

/**
 * Renders the settings field for the AWS secret.
 */
public function render_aws_secret_settings_field() {
    $settings_field_id = 'wp-license-manager-settings';
    $options = get_option( $settings_field_id );
    ?>
       <input type='text' name='<?php echo $settings_field_id; ?>[aws_secret]' value='<?php echo $options['aws_secret']; ?>' class='regular-text'>
    <?php
}

Die Rendering-Funktionen für das Einstellungsfeld render_aws_key_settings_field und render_aws_secret_settings_field sind im Wesentlichen Kopien voneinander: Zuerst rufen sie die Optionen des Plugins ab und drucken dann ein Textfeld mit Namen und aktuellem Wert der Einstellung aus.

Die Funktionen zum Rendern der Einstellungsseite (render_settings_page) und des Einstellungsabschnitts (render_aws_settings_section) sind ähnlich, aber anstatt den HTML-Code direkt in der Funktion zu drucken, verwenden sie separate HTML-Vorlagen. Dies ist keineswegs der einzig richtige Weg - ich habe mich für diesen Ansatz entschieden, da diese Funktionen etwas mehr HTML darstellen und möglicherweise zu einem späteren Zeitpunkt erweitert werden müssen.

Hier geht es um die Vorlagen. Zuerst admin/partials/settings_page.php, der Teil für die Einstellungsseite:

<?php
/**
 * The view for the plugin's options page.
 *
 * @package    Wp_License_Manager
 * @subpackage Wp_License_Manager/admin/partials
 */
?>

<div class="wrap">
    <div id="icon-edit" class="icon32 icon32-posts-post"></div>

    <h2>
        <?php _e( 'WP License Manager Settings', $this->plugin_name ); ?>
    </h2>

    <form action='options.php' method='post'>
        <?php
        settings_fields( $settings_group_id );
        do_settings_sections( $settings_group_id );
        submit_button();
        ?>
    </form>
</div>

Der interessante Teil befindet sich am Ende der PHP-Datei, wo wir das Formular erstellen und die Einstellungsfelder, Abschnitte und die Schaltfläche zum Einfügen einfügen.

Der Teil für die Einstellungen (admin/partials/aws_settings_group_instructions.php) ist derzeit fast leer und gibt eine kurze Zeile Anweisungen aus:

<?php
/**
 * The view for the AWS settings section's description on the plugin's settings page.
 *
 * @package    Wp_License_Manager
 * @subpackage Wp_License_Manager/admin/partials
 */
?>

<?php _e( 'Enter your AWS credentials below.', $this->plugin_name ); ?>

Nun haben wir die Einstellungsseite erstellt. Besuchen Sie das WordPress-Dashboard, um es in Aktion zu sehen:

Schritt 4: Erhalten Sie einen AWS-API-Schlüssel und ein Geheimnis

Um die Funktionalität zu testen, müssen Sie immer noch einen API-Schlüssel und ein Geheimnis von AWS abrufen und in den gerade erstellten Einstellungsfeldern speichern.

Kehren Sie dazu zur AWS-Administrationskonsole zurück und klicken Sie im oberen rechten Menü auf Ihren Namen. Wählen Sie in der angezeigten Dropdown-Liste Sicherheitsberechtigungsnachweise aus.

Als Nächstes wird das folgende Popup angezeigt:

Wählen Sie die Option Erste Schritte mit IAM-Benutzern aus. Auf diese Weise können Sie Ihre globalen Sicherheitsanmeldeinformationen nicht überall verwenden, sondern Sie können separate Benutzernamen (und Zugriffsberechtigungsnachweise) für verschiedene AWS-Anwendungen erstellen, die Sie möglicherweise verwenden.

Erstellen Sie anschließend einen Benutzer, der für Ihre WP License Manager-Installation verwendet werden soll.

Klicken Sie zuerst oben auf der Seite auf Create Users. Geben Sie dann auf der nächsten Seite einen Benutzernamen ein, der für Sie sinnvoll ist (ich habe einfach test_user verwendet, aber eine bessere Option wäre wahrscheinlich der license-manager oder etwas, das Ihnen sagt, wofür der Benutzer verwendet wird) und klicken Sie auf Create .

Der Benutzer wird erstellt und auf der nächsten Seite werden die Sicherheitsanmeldeinformationen angezeigt. Kopieren Sie sie und fügen Sie sie in die Einstellungen ein, die wir im vorherigen Schritt erstellt haben.

Schritt 5: Erstellen Sie die API-Funktion

Jetzt haben wir alle Teile erstellt, die für die get-API-Aktion erforderlich sind. Lassen Sie uns sie zusammenstellen und die Aktion selbst erstellen.

Füllen Sie zunächst den switch..case-Block aus, den wir für die get-Aktion in der handle_request-Funktion in Wp_License_Manager_API hinterlassen haben:

1	case 'get':
2	$response = $this->verify_license_and_execute( array( $this, 'get_product' ), $params );
3	break;

Die Funktion verify_license_and_execute ist bereits fertiggestellt. Daher müssen Sie lediglich die Handler-Funktion get_product hinzufügen.

Hier ist die Funktion:

/**
 * The handler for the "get" request. Redirects to the file download.
 *
 * @param   $product    WP_Post     The product object
 */
private function get_product( $product, $product_id, $email, $license_key ) {
    // Get the AWS data from post meta fields
    $meta = get_post_meta( $product->ID, 'wp_license_manager_product_meta', true );
    $bucket = isset ( $meta['file_bucket'] ) ? $meta['file_bucket'] : '';
    $file_name = isset ( $meta['file_name'] ) ? $meta['file_name'] : '';

    if ( $bucket == '' || $file_name == '' ) {
        // No file set, return error
        return $this->error_response( 'No download defined for product.' );
    }

    // Use the AWS API to set up the download
    // This API method is called directly by WordPress so we need to adhere to its
    // requirements and skip the JSON. WordPress expects to receive a ZIP file...

    $s3_url = Wp_License_Manager_S3::get_s3_url( $bucket, $file_name );
    wp_redirect( $s3_url, 302 );
}

Gehen wir die Funktion durch, um zu sehen, was sie bewirkt:

Zeilen 7-10: Lesen Sie die Bucket- und Dateinameneinstellungen aus den Metadaten des Produkts.

Zeilen 12-15: Wenn die Metadaten nicht festgelegt sind, geben Sie eine Fehlerantwort zurück.

Zeile 21: Verwenden Sie das AWS SDK, um eine signierte URL für die herunterladbare Datei des angeforderten Produkts zu erstellen.

Zeile 22: Weiterleitung zur signierten Download-URL bei S3. Wie wir im nächsten Schritt des Tutorials sehen werden, erwartet WordPress, dass diese Anforderung die eigentliche Datei zurückgibt. Daher müssen wir hier ein wenig von unserer JSON-basierten API umleiten und tun, was am besten für WordPress funktioniert.

Sie haben jetzt das Lizenzmanager-Plugin erstellt. Wenn Sie möchten, können Sie den Download auf dieselbe Weise testen, wie wir die Info-Anfrage zuvor getestet haben, um festzustellen, ob alles funktioniert. Statt den Fehler anzuzeigen, den wir beim direkten Zugriff auf die Datei in S3 angezeigt haben, lädt Ihr Browser die hochgeladene ZIP-Datei herunter zu S3.

Fazit

Mit der Fertigstellung der API haben wir das Lizenzmanager-Plugin nun abgeschlossen. Es gibt zwar viele Funktionen, die hinzugefügt werden können, aber die aktuelle Version ist voll funktionsfähig und kann verwendet werden, um Lizenzen erfolgreich abzuwickeln.

Im nächsten und letzten Teil der Tutorialserie werden wir alles zusammenstellen, ein WordPress-Theme erstellen und mit unserem Lizenzmanager-Server nach Updates suchen.