You can find all necessary Code for Download and Changelogs always here:
The PHP SDK for the nexxOMNIA API needs at least PHP 7.4 as Environment.
It works best when integrated via Composer 2.
composer require nexxomnia/apiclient-php
A very simple Example could be
use nexxomnia\apiclient;
use nexxomnia\apicalls\mediacall;
use nexxomnia\enums\streamtypes;
$apiclient = new apiclient();
$apicall = new mediacall(streamtypes::VIDEO);
echo $result->getResultIterator(TRUE)->current()->getGeneral()->getID(); // outputs the ID of the first Element

General Usage

For any API Call, two Classes have to be instantiated. The apiclienthas to be created only once and configured with the target Domain ID, the Domain Secret and (in most Cases) a valid Session ID - in most cases, that would be the Management Session ID.
The apiclientwill execute a valid apicall. There are many different apicallClasses for different Aspects of the API, but they all work in a similar Way.
All API Methods, as described in this Documentation, are available on the corresponding apicallClass. In most cases, the apicallClass Method is "humanized" and the Naming is less technical.
Nearly every API Method can be configured by Parameters and/or Modifiers. Consequently, each apicall Class exposes a getParameters() and a getModifiers() Method, which return Helper Classes for easier accessing the correct Parameters here:
$apicall = new mediacall(streamtypes::VIDEO);
In this simple Example, the basic Way to set Parameters is shown (the setMethod). Every valid Parameter though has also an explicit Setter (here setLimit), which additionally check Consistency and Validity of the given Parameter.
Methods with unique Parameters (like in the /manage API Endpoint), expose these Parameters directly on the Method and handle the necessary Parameter Logic themselves.
The call Method of the apiclient takes the configured API Call and directly starts it. It returns an Instance of the result Class then, which can be handled like this:
$result = $apiclient->call($apicall);
echo $result->getMetadata()->getErrorHint();
The resultClass can directly return the received JSON via getRawResponse- or, only the "result" Part of the Response via getResult.
For more advanced Usage, it can also return an Instance of the resultobjectClass, which allows to query the JSON in a more human Way:
$id = $result->getRawResponse()["result"]["general"]["ID"];
$id = $result->getResultObject()->getGeneral()->getID();
Especially the media API returns very often Lists of Media Objects. For Iterating directly over the JSON Array, the result Class exposes an Iterator via getResultIterator. The Iterator itself can return the pure JSON Objects or resultobject Class Instances as above.

Creating new Elements

Media Creation via API

The SDK allows also to create new Media. Technically, there are Media Types, that need an initial File (like a Video), and Media Types, that exist of Data alone (an Article for example).
File-driven Media Types can be created by giving a URL, that the API will use to download and process the Input and create an Item from it:
use nexxomnia\apicalls\mediamanagementcall;
use nexxomnia\enums\streamtypes;
$apicall = new mediamanagementcall();
$result = $apiclient->call($apicall);
// the ID of the new Video via ResultObject:
$videoID = $result->getResultObject()->getGeneratedID();
// or via JSON Objects:
$videoID = $result->getResult()['itemupdate']['generatedID'];
Data-driven Media Types will be created like this:
use nexxomnia\apicalls\mediamanagementcall;
use nexxomnia\enums\streamtypes;
$apicall = new mediamanagementcall();
$apicall->createFromData("Article Title","Article Refnr");
$result = $apiclient->call($apicall);
// the ID of the new Article via ResultObject:
$articleID = $result->getResultObject()->getGeneratedID();
// or via JSON Objects:
$articleID = $result->getResult()['itemupdate']['generatedID'];

Creating Structure Elements

Structure Elements like Channels, Formats and Categories are not Media Items. They exist on the Domain Level only and can be created like Data-driven Elements via API:
use nexxomnia\apicalls\domainmanagementcall;
$apicall = new domainmanagementcall();
$result = $apiclient->call($apicall);
// the ID of the new Channel
$channelID = $result->getResultObject()->getGeneratedID();
// or via JSON Objects:
$channelID = $result->getResult()['itemupdate']['generatedID'];
The Attributes for this Example are listed in the Domain Management API:

Media Creation via UploadHandler

Alternatively, you can upload a local File directly with the uploadhandlerClass:
use nexxomnia\uploadhandler;
use nexxomnia\enums\streamtypes;
$uploadhandler = new uploadhandler();
$apiresult = $uploadhandler->uploadMedia($localPath,streamtypes::VIDEO);
//the UploadHandler returns an API Result, that can be used as usual
$videoID = $apiresult->getResultObject()->getGeneratedID();

Using the UploadHandler

Besides the pure Upload of new Media Files, the UploadHandler offers even more Helpers for all API Endpoints, that need a phsyical File (like Covers and Captions):
use nexxomnia\uploadhandler;
use nexxomnia\enums\streamtypes;
use nexxomnia\enums\covertypes;
$uploadhandler = new uploadhandler();

Available APICall Classes

Media API

The most important Difference to other Classes here is the need for setting the target Streamtype (in the Constructor or via explicit Method). By default, the Class uses "video" as Streamtype. You can use the Enum Class nexxomnia\enums\streamtypes to be sure or just use a String.
The Media API offers by far the highest Amount of Modifiers and Parameters, which are exposed as described above. It also nearly always returns Lists of Media, which implies using the Interator Object on the result Class.
Very often, it is necessary to get all possible Results in one Array. The API itself does not return more than 100 Elements per Call, but if all possible Results are needd, the callMethod of the apiclientoffers a second Parameter, which will handle the Parameters and Interating over the API Responses to construct a resultObject with indeed all Result Objects.

Management APIs

As the Management API offers by far the most Methods, the API Client offers mediamanagement and domainmanagement Classes for the corresponding Method Helpers.
Like the Media API, the Classes offer a setStreamtypeand a setItemMethod, which is extremely helpfull especially on Media Management, where one specific Media Item of a specific Streamtype should be modified.

Statistics API

The Statistics API returns in nearly every case lists of Key=>Value Pairs. Therefore, the Usage of the getResultMethod of the responseObject is is most cases sufficient.
Please notice, that some Methods can return huge Lists. As Paging is not supported in this API, you can set the Limit to higher Values (like 100000). Furthermore, this API might take longer than all other APIs, as it returns realtime Data. The apiclient therefore sets a Timeout of 30 Seconds by default, it Endpoints of this API are called. It is possible though to raise this Value even more:

Domain API

The Domain API exposes various structural Objects, that are connected to a Domain. The classic Example is a List of Channels via getChannels. In most Cases, the response should be iterated over with an Iterator, but as most Lists are very short and Paging is (in most Cases) not supported, the getResultMethod is enough.

System API

The System API is very straight forward, as it basically only returns Objects/Arrays of System Constants. The Usage of the getResultMethod of the responseObject is is most cases sufficient.

Session API

The Session API is available in the SDK, but in nearly every Case, this Backend SDK should use the constant "Management Session", given by 3Q nexx. Nevertheless, it is possible to start and extend Sessions with this Class, if needed.

Processing API

The most important Method of the Processing API is the MultiTask Method, which allows to query multiple API Endpoints at the same time. To make sure, the Parameters are built correctly, each Task, that is given to the Method is itself a Class. It is used like this:
use nexxomnia\apicalls\processingcall;
use nexxomnia\apicalls\helpers\task;
use nexxomnia\enums\streamtypes;
$apicall = new processingcall();
$tasks = [];
$task = new task("task-1");

Custom APICall

For advanced Usage, you can omit all predefined Methods and Helpers and use a custom APICall. Please notice, that in this Case, you have to be very sure about the right Endpoints, Methods, HTTP Verbs and Parameters.
use nexxomnia\apicalls\customcall;
use nexxomnia\enums\defaults;
use nexxomnia\enums\streamtypes;
$apicall = new customcall();
Last modified 1yr ago