API-Funktionen Migration REDAXO 5 → 6

Diese Dokumentation zeigt die Änderungen an API-Funktionen zwischen REDAXO 5.x und REDAXO 6.x.

Übersicht der API-Klassen

API-Funktionen wurden reorganisiert und in thematisch passende Namespaces verschoben.

Core API

REDAXO 5.x	REDAXO 6.x	Beschreibung
`rex_api_function`	`Redaxo\Core\ApiFunction\ApiFunction`	Basis-Klasse
`rex_api_result`	`Redaxo\Core\ApiFunction\Result`	Ergebnis-Klasse
`rex_api_exception`	`Redaxo\Core\ApiFunction\Exception\ApiFunctionException`	Exception

Addon/Package API

REDAXO 5.x	REDAXO 6.x	Beschreibung
`rex_api_package`	`Redaxo\Core\Addon\ApiFunction\AddonOperation`	Add-on Operationen

Security/User API

REDAXO 5.x	REDAXO 6.x	Beschreibung
`rex_api_has_user_session`	`Redaxo\Core\Security\ApiFunction\UserHasSession`	Session-Prüfung
`rex_api_user_impersonate`	`Redaxo\Core\Security\ApiFunction\UserImpersonate`	Benutzer wechseln
`rex_api_user_remove_auth_method`	`Redaxo\Core\Security\ApiFunction\UserRemoveAuthMethod`	Auth-Methode entfernen
`rex_api_user_remove_session`	`Redaxo\Core\Security\ApiFunction\UserRemoveSession`	Session entfernen
`rex_api_user_session_status`	`Redaxo\Core\Security\ApiFunction\UserSessionStatus`	Session-Status

Content/Structure API

REDAXO 5.x	REDAXO 6.x	Beschreibung
`rex_api_article_add`	`Redaxo\Core\Content\ApiFunction\ArticleAdd`	Artikel hinzufügen
`rex_api_article_copy`	`Redaxo\Core\Content\ApiFunction\ArticleCopy`	Artikel kopieren
`rex_api_article_delete`	`Redaxo\Core\Content\ApiFunction\ArticleDelete`	Artikel löschen
`rex_api_article_edit`	`Redaxo\Core\Content\ApiFunction\ArticleEdit`	Artikel bearbeiten
`rex_api_article_move`	`Redaxo\Core\Content\ApiFunction\ArticleMove`	Artikel verschieben
`rex_api_article_status`	`Redaxo\Core\Content\ApiFunction\ArticleStatusChange`	Artikel-Status
`rex_api_article2category`	`Redaxo\Core\Content\ApiFunction\ArticleToCategory`	Artikel → Kategorie
`rex_api_article2startarticle`	`Redaxo\Core\Content\ApiFunction\ArticleToStartArticle`	Artikel → Startartikel
`rex_api_category_add`	`Redaxo\Core\Content\ApiFunction\CategoryAdd`	Kategorie hinzufügen
`rex_api_category_delete`	`Redaxo\Core\Content\ApiFunction\CategoryDelete`	Kategorie löschen
`rex_api_category_edit`	`Redaxo\Core\Content\ApiFunction\CategoryEdit`	Kategorie bearbeiten
`rex_api_category_move`	`Redaxo\Core\Content\ApiFunction\CategoryMove`	Kategorie verschieben
`rex_api_category_status`	`Redaxo\Core\Content\ApiFunction\CategoryStatusChange`	Kategorie-Status
`rex_api_category2article`	`Redaxo\Core\Content\ApiFunction\CategoryToArticle`	Kategorie → Artikel
`rex_api_content_copy`	`Redaxo\Core\Content\ApiFunction\ContentCopy`	Inhalt kopieren
`rex_api_content_move_slice`	`Redaxo\Core\Content\ApiFunction\ArticleSliceMove`	Slice verschieben
`rex_api_content_slice_status`	`Redaxo\Core\Content\ApiFunction\ArticleSliceStatusChange`	Slice-Status

MetaInfo API

REDAXO 5.x	REDAXO 6.x	Beschreibung
`rex_api_metainfo_default_fields_create`	`Redaxo\Core\MetaInfo\ApiFunction\DefaultFieldsCreate`	Standard-Felder erstellen

Eigene API-Funktion erstellen

REDAXO 5.x

<?php

class rex_api_myfunction extends rex_api_function
{
    protected $published = true;  // Öffentlich zugänglich
    
    public function execute()
    {
        $id = rex_get('id', 'int');
        
        // Daten verarbeiten
        
        return new rex_api_result(true, 'Erfolgreich ausgeführt');
    }
}

REDAXO 6.x

<?php

namespace MyAddon\ApiFunction;

use Redaxo\Core\ApiFunction\ApiFunction;
use Redaxo\Core\ApiFunction\Result;
use Redaxo\Core\Http\Request;

class MyFunction extends ApiFunction
{
    protected bool $published = true;  // Öffentlich zugänglich
    
    public function execute(): Result
    {
        $id = Request::get('id', 'int');
        
        // Daten verarbeiten
        
        return new Result(true, 'Erfolgreich ausgeführt');
    }
}

API-Aufruf

URL-Generierung

// REDAXO 5.x
$url = rex_url::backendPage('mypage', [
    'rex-api-call' => 'myfunction',
    'id' => 5
]);

// REDAXO 6.x
use Redaxo\Core\Filesystem\Url;

$url = Url::backendPage('mypage', [
    'rex-api-call' => 'myfunction',
    'id' => 5
]);

API-Ergebnis verarbeiten

// REDAXO 5.x
$apiResult = rex_api_function::getResult();
if ($apiResult && $apiResult->isSuccessful()) {
    echo rex_view::success($apiResult->getMessage());
}

// REDAXO 6.x
use Redaxo\Core\ApiFunction\ApiFunction;
use Redaxo\Core\View\Message;

$apiResult = ApiFunction::getResult();
if ($apiResult && $apiResult->isSuccessful()) {
    echo Message::success($apiResult->getMessage());
}

Exception Handling

REDAXO 5.x

<?php

class rex_api_myfunction extends rex_api_function
{
    public function execute()
    {
        if (!$condition) {
            throw new rex_api_exception('Fehler: Bedingung nicht erfüllt');
        }
        
        return new rex_api_result(true, 'OK');
    }
}

REDAXO 6.x

<?php

namespace MyAddon\ApiFunction;

use Redaxo\Core\ApiFunction\ApiFunction;
use Redaxo\Core\ApiFunction\Result;
use Redaxo\Core\ApiFunction\Exception\ApiFunctionException;

class MyFunction extends ApiFunction
{
    public function execute(): Result
    {
        if (!$condition) {
            throw new ApiFunctionException('Fehler: Bedingung nicht erfüllt');
        }
        
        return new Result(true, 'OK');
    }
}

Vollständiges Beispiel

REDAXO 5.x

<?php

class rex_api_article_publish extends rex_api_function
{
    protected $published = true;
    
    public function execute()
    {
        $articleId = rex_request('article_id', 'int');
        $clangId = rex_request('clang_id', 'int', rex_clang::getCurrentId());
        
        // CSRF-Prüfung
        if (!rex_csrf_token::factory('article_publish')->isValid()) {
            throw new rex_api_exception('CSRF-Token ungültig');
        }
        
        // Artikel laden
        $article = rex_article::get($articleId, $clangId);
        if (!$article) {
            throw new rex_api_exception('Artikel nicht gefunden');
        }
        
        // Artikel veröffentlichen
        $sql = rex_sql::factory();
        $sql->setTable(rex::getTable('article'));
        $sql->setWhere(['id' => $articleId, 'clang_id' => $clangId]);
        $sql->setValue('status', 1);
        $sql->update();
        
        // Cache löschen
        rex_article_cache::delete($articleId, $clangId);
        
        return new rex_api_result(true, 'Artikel wurde veröffentlicht');
    }
}

REDAXO 6.x

<?php

namespace MyAddon\ApiFunction;

use Redaxo\Core\ApiFunction\ApiFunction;
use Redaxo\Core\ApiFunction\Result;
use Redaxo\Core\ApiFunction\Exception\ApiFunctionException;
use Redaxo\Core\Content\Article;
use Redaxo\Core\Content\ArticleCache;
use Redaxo\Core\Core;
use Redaxo\Core\Database\Sql;
use Redaxo\Core\Http\Request;
use Redaxo\Core\Language\Language;
use Redaxo\Core\Security\CsrfToken;

class ArticlePublish extends ApiFunction
{
    protected bool $published = true;
    
    public function execute(): Result
    {
        $articleId = Request::request('article_id', 'int');
        $clangId = Request::request('clang_id', 'int', Language::getCurrentId());
        
        // CSRF-Prüfung
        if (!CsrfToken::factory('article_publish')->isValid()) {
            throw new ApiFunctionException('CSRF-Token ungültig');
        }
        
        // Artikel laden
        $article = Article::get($articleId, $clangId);
        if (!$article) {
            throw new ApiFunctionException('Artikel nicht gefunden');
        }
        
        // Artikel veröffentlichen
        $sql = Sql::factory();
        $sql->setTable(Core::getTable('article'));
        $sql->setWhere(['id' => $articleId, 'clang_id' => $clangId]);
        $sql->setValue('status', 1);
        $sql->update();
        
        // Cache löschen
        ArticleCache::delete($articleId, $clangId);
        
        return new Result(true, 'Artikel wurde veröffentlicht');
    }
}

Registrierung der API-Funktion

REDAXO 5.x (boot.php)

<?php

// API-Funktion wird automatisch über Klassennamen registriert
// Datei: lib/api_function/rex_api_article_publish.php

REDAXO 6.x (boot.php)

<?php

use Redaxo\Core\ApiFunction\ApiFunction;
use MyAddon\ApiFunction\ArticlePublish;

// API-Funktion registrieren
ApiFunction::register('article_publish', ArticlePublish::class);