Példakódok

A példakódokok PHP 8.1-ben, Guzzle 7.5 segítségével készültek.

Autentikáció

Bejelentkezés e-mail címmel és jelszóval

A bejelentkezéshez a /authentication/login-ra kell küldeni egy application/x-www-form-urlencoded formátumú POST üzenetet.

Példa:

$client = new GuzzleHttp\Client();

$email = "[email protected]";
$password = "test123";

try {
    $response = $client->post('https://devapi.ilogistic.eu/authentication/login', [
        'form_params' => [
            "Email" => $email,
            "Password" => $password,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $token = json_decode(
        $response->getBody()->getContents()
    )->token;
    
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Post üzenet elküldése az API számára:

$response = $client->post('https://devapi.ilogistic.eu/authentication/login', [
    'form_params' => [
        "Email" => $email,
        "Password" => $password,
    ]
]);

A GuzzleHttp\Client típusú $client, post() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a form_params indexű elemében található tömb tartalmazza a bejelentkezési adatokat. A tömb Email indexű eleme a felhasználó e-mail címét, a Password indexű eleme pedig a felhasználó jelszavát tartalmazza.

Válasz feldolgozása:

$statusCode = $response->getStatusCode();
$token = json_decode(
    $response->getBody()->getContents()
)->token;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getStatusCode() függvényével kaphatjuk meg az API által küldött HTTP válasz státusz kódját.

A $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum token tulajdonsága tartalmazza a bejelentkezés során kapott tokent.

Hibakezelés:

catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A catch segítségével elkapjuk a kérés elküldése során keletkezett hibákat, amik GuzzleHttp\Exception\RequestException tipusúak. Az $exception változó getCode() függvényével kapjuk meg az API által küldött HTTP válasz státusz kódját.

Az $exception getResponse() függvénnyel megkaphatjuk az API által küldött választ, amin a getBody()->getContents() függvényeket meghívva megkapjuk a body-t json formátumban. Ezt a json_decode() függvénnyel feldolgozva egy olyan objektumot kapunk, aminek az error tulajdonsága tartalmazza a hibaüzenetet.

Hitelesítés tokennel

Ha már van egy tokenünk, akkor egy /authentication/auth-ra küldött GET üzenettel kérhetünk új tokent.

Példa:

$client = new GuzzleHttp\Client();

try {
    $response = $client->get('https://devapi.ilogistic.eu/authentication/login', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);
    
    $statusCode = $response->getStatusCode();
    $token = json_decode(
        $response->getBody()->getContents()
    )->token;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Get üzenet küldése az API számára:

$response = $client->get('https://devapi.ilogistic.eu/authentication/login', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Válasz feldolgozása:

$statusCode = $response->getStatusCode();
$token = json_decode(
    $response->getBody()->getContents()
)->token;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum token tulajdonsága tartalmazza az új tokent.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Token érvényességének ellenőrzése

A token érvényességét a /authentication/validate-re küldött GET üzenettel lehet ellenőrizni.

Példa:

$client = new GuzzleHttp\Client();

try {
    $response = $client->get('https://devapi.ilogistic.eu/authentication/validate', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $isValid = json_decode(
        $response->getBody()->getContents()
    )->valid;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Get üzenet küldése az API számára:

$response = $client->get('https://devapi.ilogistic.eu/authentication/validate', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval. (Ennek a tokennek az érvényessége lesz ellenőrizve.)

Válasz feldolgozása:

$statusCode = $response->getStatusCode();
$isValid = json_decode(
    $response->getBody()->getContents()
)->valid;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektumnak, a bool típusú, valid tulajdonsága jelzi, hogy érvényes-e a token. (Ha true akkor érvényes, ha false akkor érvénytelen a token.)

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Rendelések

Rendelések lekérdezése

A rendelések lekérdezéséhez az /orders/orders-re kell küldeni egy GET kérést.

Példa:

$client = new GuzzleHttp\Client();

try {
    $response = $client->get('https://devapi.ilogistic.eu/orders/orders', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $orders = json_decode(
        $response->getBody()->getContents()
    );
    $firstOrder = $orders[0];

    foreach ($orders as $order){
        echo $order->id;
    }
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A rendelések lekérdezése az API-tól:

$response = $client->get('https://devapi.ilogistic.eu/orders/orders', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API-tól kapott válasz feldolgozása:

$orders = json_decode(
   $response->getBody()->getContents()
);
$firstOrder = $orders[0];

foreach ($orders as $order){
   $orderId = $order->id;
}

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni.

Az így kapott array-t, ami tartalmazza a megrendeléseket, az $orders változóba mentettük el. Ennek az array-nek kivehetjük tetszőleges indexű elemét, úgy, mint ahogy a $firstOrder változóba kivettük az array első elemét.

Egy foreach-el végig mehetünk az $orders összes elemén, és ahhoz hasonlóan, ahogy a példában elértük az egyes rendelések id-ját, elérjük a rendelések többi tulajdonságát is.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Rendelés létrehozása

Egy új rendelés létrehozásához az /orders/orders-re kell küldeni egy POST üzenetet, ami a body-jában tartalmazza az új rendelés adatait json formátumban.

Példa:

$client = new GuzzleHttp\Client();

try {
    $newOrderJson = json_encode(
        [
            'foreignId' => 'I-24532',
            'delivery' => [
                'name' => 'Teszt Elek',
                'email' => '[email protected]',
                'phoneNumber' => '+36701234567',
                'country' => 'HU',
                'postCode' => '1234',
                'city' => 'Budapest',
                'address' => 'Petőfi Sándor u. 4.',
                'company' => 'GLS',
                'aptNumber' => 'GLS-123g31G',
            ],
            'billing' => [
                'name' => 'Teszt Elek',
                'email' => '[email protected]',
                'phoneNumber' => '+36701234567',
                'country' => 'HUN',
                'postCode' => '1234',
                'city' => 'Budapest',
                'address' => 'Petőfi Sándor u. 4.',
            ],
            'payment' => [
                'type' => 'Utánvétes fizetés',
                'cost' => 1000,
            ],
            'content' => [
                [
                    'itemNumber' => '00149978438',
                    'quantity' => 2,
                ],
            ],
        ]
    );

    $response = $client->post('https://devapi.ilogistic.eu/orders/orders', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $newOrderJson
    ]);

    $statusCode = $response->getStatusCode();
    $newOrderId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Az új rendelést tartalmazó JSON létrehozása

$newOrderJson = json_encode(
    [
        'foreignId' => 'I-24532',
        'delivery' => [
            'name' => 'Teszt Elek',
            'email' => '[email protected]',
            'phoneNumber' => '+36701234567',
            'country' => 'HU',
            'postCode' => '1234',
            'city' => 'Budapest',
            'address' => 'Petőfi Sándor u. 4.',
            'company' => 'GLS',
            'aptNumber' => 'GLS-123g31G',
        ],
        'billing' => [
            'name' => 'Teszt Elek',
            'email' => '[email protected]',
            'phoneNumber' => '+36701234567',
            'country' => 'HUN',
            'postCode' => '1234',
            'city' => 'Budapest',
            'address' => 'Petőfi Sándor u. 4.',
        ],
        'payment' => [
            'type' => 'Utánvétes fizetés',
            'cost' => 1000,
        ],
        'content' => [
            [
                'itemNumber' => '00149978438',
                'quantity' => 2,
            ],
        ],
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a létrehozandó rendelés adatait. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $newOrderJson változóba.

A rendelés létrehozásához szükséges POST üzenet elküldése:

$response = $client->post('https://devapi.ilogistic.eu/orders/orders', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
        'Content-Type' => 'application/json',
    ],
    'body' => $newOrderJson
]);

A GuzzleHttp\Client típusú $client, post() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $newOrderJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

$newOrderId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a létrehozott rendelés azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Megrendelés lekérdezése azonosító alapján

Egy megrendelés lekérdezéséhez az /orders/order/{id} címre kell küldeni egy GET kérést, ahol a címben szereplő {id} helyére kell beilleszteni a lekérdezni kívánt megrendelés azonosítóját (id).

Példa:

$client = new GuzzleHttp\Client();

$orderId = 55162;

try {
    $response = $client->get('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $order = json_decode(
        $response->getBody()->getContents()
    );
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

GET üzenet elküldése a megrendelés lekérdezéséhez:

$response = $client->get('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a lekérdezni kívánt megrendelés azonosítója, amit a példában az $orderId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API által küldött válasz feldolgozása:

$order = json_decode(
    $response->getBody()->getContents()
);

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum tartalmazza a lekérdezett megrendelést.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Megrendelés módosítása

Egy megrendelés módosításához a /orders/order/{id} címre kell küldeni egy PATCH kérést, ahol a címben szereplő {id} helyére kell beilleszteni a módosítani kívánt megrendelés azonosítóját (id), a body-jába pedig a megrendelés, módosítani kívánt adatait kell helyezni, JSON formátumban.

Példa:

$client = new GuzzleHttp\Client();

$orderId = 55162;

try {
    $editedOrderJson = json_encode(
        [
            'foreignId' => 'ss',
            'delivery' => [
                'name' => 'Teszt Elek',
                'email' => '[email protected]',
                'phoneNumber' => '+36701234567',
                'country' => 'HU',
                'postCode' => '1234',
                'city' => 'Budapest',
                'address' => 'Petőfi Sándor u. 4.',
                'company' => 'GLS',
                'aptNumber' => 'GLS-123g31G',
            ],
            'billing' => [
                'name' => 'Teszt Elek',
                'email' => '[email protected]',
                'phoneNumber' => '+36701234567',
                'country' => 'HUN',
                'postCode' => '1234',
                'city' => 'Budapest',
                'address' => 'Petőfi Sándor u. 4.',
            ],
            'payment' => [
                'type' => 'Utánvétes fizetés',
                'cost' => 1000,
            ],
            'content' => [
                [
                    'itemNumber' => '1234566789',
                    'quantity' => 2,
                ],
            ],
        ]
    );
    $response = $client->patch('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $editedOrderJson,
    ]);

    $statusCode = $response->getStatusCode();
    $editedOrderId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Az rendelés módosítani kívánt adatait tartalmazó JSON létrehozása:

$editedOrderJson = json_encode(
    [
        'foreignId' => 'ss',
        'delivery' => [
            'name' => 'Teszt Elek',
            'email' => '[email protected]',
            'phoneNumber' => '+36701234567',
            'country' => 'HU',
            'postCode' => '1234',
            'city' => 'Budapest',
            'address' => 'Petőfi Sándor u. 4.',
            'company' => 'GLS',
            'aptNumber' => 'GLS-123g31G',
        ],
        'billing' => [
            'name' => 'Teszt Elek',
            'email' => '[email protected]',
            'phoneNumber' => '+36701234567',
            'country' => 'HUN',
            'postCode' => '1234',
            'city' => 'Budapest',
            'address' => 'Petőfi Sándor u. 4.',
        ],
        'payment' => [
            'type' => 'Utánvétes fizetés',
            'cost' => 1000,
        ],
        'content' => [
            [
                'itemNumber' => '1234566789',
                'quantity' => 2,
            ],
        ],
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a módosítandó rendelés azon adatait, amiket módosítani szeretnénk. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $editedOrderJson változóban.

A rendelés módosításához szükséges PATCH üzenet elküldése:

$response = $client->patch('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
        'Content-Type' => 'application/json',
    ],
    'body' => $editedOrderJson,
]);

A GuzzleHttp\Client típusú $client, patch() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a módosítani kívánt megrendelés azonosítója, amit a példában az $orderiD változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $editedOrderJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

$editedOrderId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a módosított rendelés azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Megrendelés törlése

Egy megrendelés törléséhez az /orders/order/{id} címre kell küldeni egy DELETE kérést, ahol a címben szereplő {id} helyére kell beilleszteni a törölni kívánt megrendelés azonosítóját (id).

Példa:

$client = new GuzzleHttp\Client();

$orderId = 55162;

try {
    $response = $client->delete('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $deletedOrderId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

DELETE üzenet elküldése a megrendelés törléséhez:

$response = $client->delete('https://devapi.ilogistic.eu/orders/order/' . $orderId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, delete() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a törölni kívánt megrendelés azonosítója, amit a példában az $orderId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API által küldött válasz feldolgozása:

$deletedOrderId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a törölt rendelés azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Termékek

Termékek lekérdezése

A termékek lekérdezéséhez a /products/products-re kell küldeni egy GET kérést.

Példa:

$client = new GuzzleHttp\Client();

try {
    $response = $client->get('https://devapi.ilogistic.eu/products/products', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $products = json_decode(
        $response->getBody()->getContents()
    );
    
    $firstProduct = $products[0];

    foreach ($products as $product){
        $productId = $product->id;
    }
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A termékek lekérdezése az API-tól:

$response = $client->get('https://devapi.ilogistic.eu/products/products', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API-tól kapott válasz feldolgozása:

$products = json_decode(
   $response->getBody()->getContents()
);

$firstProduct = $products[0];

foreach ($products as $product){
   $productId = $product->id;
}

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni.

Az így kapott array-t, ami tartalmazza a termékeket, a $products változóba mentettük el. Ennek az array-nek kivehetjük tetszőleges indexű elemét, úgy, mint ahogy a $firstProduct változóba kivettük az array első elemét.

Egy foreach-el végig mehetünk az $products összes elemén, és ahhoz hasonlóan, ahogy a példában elértük az egyes termékek id-ját, elérjük a termékek többi tulajdonságát is.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Termék létrehozása

Egy új termék létrehozásához az /products/products-re kell küldeni egy POST üzenetet, ami a body-jában tartalmazza az új termék adatait json formátumban.

Példa:

$client = new GuzzleHttp\Client();

try {
    $newProductJson = json_encode(
        [
            'itemNumber' => 'Tej-9761',
            'barCode' => [
                "5998900130062",
                "5998900130063",
            ],
            'name' => 'Teszt Sajt',
            'type' => 'Tej,',
            'category' => 'termek',
            'weight' => 11,
            'width' => 25,
            'depth' => 10,
            'height' => 45,
            'fragile' => 1,
            'price' => 350,
            'hasSerial' => false,
            'hasExpirationDate' => false,
            'tax' => 27,
            'critical' => 10,
        ]
    );
    $response = $client->post('https://devapi.ilogistic.eu/products/products', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $newProductJson,
    ]);

    $statusCode = $response->getStatusCode();
    $newProductId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Az új terméket tartalmazó JSON létrehozása

$newProductJson = json_encode(
    [
        'itemNumber' => 'Tej-9761',
        'barCode' => [
            "5998900130062",
            "5998900130063",
        ],
        'name' => 'Teszt Sajt',
        'type' => 'Tej,',
        'category' => 'termek',
        'weight' => 11,
        'width' => 25,
        'depth' => 10,
        'height' => 45,
        'fragile' => 1,
        'price' => 350,
        'hasSerial' => false,
        'hasExpirationDate' => false,
        'tax' => 27,
        'critical' => 10,
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a létrehozandó termék adatait. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $newProductJson változóba.

A termék létrehozásához szükséges POST üzenet elküldése:

$response = $client->post('https://devapi.ilogistic.eu/products/products', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $newProductJson,
    ]);

A GuzzleHttp\Client típusú $client, post() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $newProductJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

$newProductId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a létrehozott termék azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Termék lekérdezése azonosító alapján

Egy termék lekérdezéséhez az /products/product/{id} címre kell küldeni egy GET kérést, ahol a címben szereplő {id} helyére kell beilleszteni a lekérdezni kívánt termék azonosítóját (id).

Példa:

$client = new GuzzleHttp\Client();

$productId = 3022266;

try {
    $response = $client->get('https://devapi.ilogistic.eu/products/product/' . $productId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $product = json_decode(
        $response->getBody()->getContents()
    )[0];
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

GET üzenet elküldése a termék lekérdezéséhez:

$response = $client->get('https://devapi.ilogistic.eu/products/product/' . $productId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a lekérdezni kívánt termék azonosítója, amit a példában az $productId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API által küldött válasz feldolgozása:

$product = json_decode(
    $response->getBody()->getContents()
)[0];

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Így egy array-t kapunk, aminek az első eleme a lekérdezett terméket tartalmazó objektum.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Termék módosítása

Egy termék módosításához a /products/product/{id} címre kell küldeni egy PATCH kérést, ahol a címben szereplő {id} helyére kell beilleszteni a módosítani kívánt termék azonosítóját (id), a body-jába pedig a megrendelés, módosítani kívánt adatait kell helyezni, JSON formátumban.

Példa:

$client = new GuzzleHttp\Client();

$productId = 3022266;

try {
    $editedProductJson = json_encode(
        [
            'itemNumber' => 'Tej-9761',
            'barCode' => [
                "5998900130062",
                "5998900130063",
            ],
            'name' => 'Teszt Sajt',
            'type' => 'Tej,',
            'category' => 'termek',
            'weight' => 11,
            'width' => 25,
            'depth' => 10,
            'height' => 45,
            'fragile' => 1,
            'price' => 350,
            'hasSerial' => false,
            'hasExpirationDate' => false,
            'tax' => 27,
            'critical' => 10,
            'bundleDescription' => 'Wrap it with green paper.',
            'needsPackage' => true,
            'contents' => [
                [
                    'itemNumber' => '00149978438',
                    'quantity' => 2,
                ]
            ],
        ]
    );
    $response = $client->patch('https://devapi.ilogistic.eu/products/product/' . $productId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $editedProductJson,
    ]);

    $statusCode = $response->getStatusCode();
    $editedProductId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A termék módosítani kívánt adatait tartalmazó JSON létrehozása:

$editedProductJson = json_encode(
    [
        'itemNumber' => 'Tej-9761',
        'barCode' => [
            "5998900130062",
            "5998900130063",
        ],
        'name' => 'Teszt Sajt',
        'type' => 'Tej,',
        'category' => 'termek',
        'weight' => 11,
        'width' => 25,
        'depth' => 10,
        'height' => 45,
        'fragile' => 1,
        'price' => 350,
        'hasSerial' => false,
        'hasExpirationDate' => false,
        'tax' => 27,
        'critical' => 10,
        'bundleDescription' => 'Wrap it with green paper.',
        'needsPackage' => true,
        'contents' => [
            [
                'itemNumber' => '00149978438',
                'quantity' => 2,
            ]
        ],
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a módosítandó termék azon adatait, amiket módosítani szeretnénk. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $editedProductJson változóban.

A termék módosításához szükséges PATCH üzenet elküldése:

$response = $client->patch('https://devapi.ilogistic.eu/products/product/' . $productId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
        'Content-Type' => 'application/json',
    ],
    'body' => $editedProductJson,
]);

A GuzzleHttp\Client típusú $client, patch() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a módosítani kívánt termék azonosítója, amit a példában a $productId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $editedProductJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

$editedProductId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a módosított termék azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Bevételezés

Beszállítások lekérdezése

A beszállítások lekérdezéséhez a /inward-handling-re kell küldeni egy GET kérést.

Példa:

$client = new GuzzleHttp\Client();

try {
    $response = $client->get('https://devapi.ilogistic.eu/inward-handling', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $shipments = json_decode(
        $response->getBody()->getContents()
    );
    $firstShipment = $shipments[0];
    
    foreach ($shipments as $shipment){
        $shipmentId = $shipment->id;
    }
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A beszállítások lekérdezése az API-tól:

$response = $client->get('https://devapi.ilogistic.eu/inward-handling', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API-tól kapott válasz feldolgozása:

$shipments = json_decode(
   $response->getBody()->getContents()
);
$firstShipment = $shipments[0];

foreach ($shipments as $shipment){
   $shipmentId = $shipment->id;
}

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni.

Az így kapott array-t, ami tartalmazza a beszállításokat, a $shipments változóba mentettük el. Ennek az array-nek kivehetjük tetszőleges indexű elemét, úgy, mint ahogy a $firstShipment változóba kivettük az array első elemét.

Egy foreach-el végig mehetünk az $shipments összes elemén, és ahhoz hasonlóan, ahogy a példában elértük az egyes beszállítások id-ját, elérjük a beszállítások többi tulajdonságát is.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Beszállítás létrehozása

Egy új beszállítás létrehozásához az /inward-handling-re kell küldeni egy POST üzenetet, ami a body-jában tartalmazza az új beszállítás adatait json formátumban.

Példa:

$client = new GuzzleHttp\Client();

try {
    $newShipmentJson = json_encode(
        [
            'name' => 'Szótárak beszállítás',
            'estimatedArrival' => '2021-05-28',
            'urgent' => false,
            'description' => 'Ebben a beszállításban angol-magyar szótárak érkeznek.',
            'contents' => [
                [
                    'itemNumber' => '442345522',
                    'estimated' => 2,
                ],
            ],
        ]
    );
    $response = $client->post('https://devapi.ilogistic.eu/inward-handling', [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $newShipmentJson,
    ]);

    $statusCode = $response->getStatusCode();
    $newShipmentId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

Az új beszállítást tartalmazó JSON létrehozása

$newShipmentJson = json_encode(
    [
        'name' => 'Szótárak beszállítás',
        'estimatedArrival' => '2021-05-28',
        'urgent' => false,
        'description' => 'Ebben a beszállításban angol-magyar szótárak érkeznek.',
        'contents' => [
            [
                'itemNumber' => '442345522',
                'estimated' => 2,
            ],
        ],
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a létrehozandó beszállítás adatait. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $newShipmentJson változóba.

A beszállítás létrehozásához szükséges POST üzenet elküldése:

$response = $client->post('https://devapi.ilogistic.eu/inward-handling', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
        'Content-Type' => 'application/json',
    ],
    'body' => $newShipmentJson,
]);

A GuzzleHttp\Client típusú $client, post() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, a második paraméterében pedig egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $newShipmentJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

$newShipmentId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a létrehozott beszállítás azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Beszállítás módosítása

Egy beszállítás módosításához a /inward-handling/{id} címre kell küldeni egy PATCH kérést, ahol a címben szereplő {id} helyére kell beilleszteni a módosítani kívánt beszállítás azonosítóját (id), a body-jába pedig a beszállítás, módosítani kívánt adatait kell helyezni, JSON formátumban.

Példa:

$client = new GuzzleHttp\Client();

$shipmentId = 1;

try {
    $editedShipmentJson = json_encode(
        [
            'name' => 'Szótárak beszállítás',
            'estimatedArrival' => '2021-05-28',
            'urgent' => false,
            'description' => 'Ebben a beszállításban angol-magyar szótárak érkeznek.',
            'contents' => [
                [
                    'itemNumber' => '442345522',
                    'estimated' => 2,
                ],
            ],
        ]
    );
    
    $response = $client->patch('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
            'Content-Type' => 'application/json',
        ],
        'body' => $editedShipmentJson,
    ]);

    $statusCode = $response->getStatusCode();
    $editedShipmentId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

A beszállítás módosítani kívánt adatait tartalmazó JSON létrehozása:

$editedShipmentJson = json_encode(
    [
        'name' => 'Szótárak beszállítás',
        'estimatedArrival' => '2021-05-28',
        'urgent' => false,
        'description' => 'Ebben a beszállításban angol-magyar szótárak érkeznek.',
        'contents' => [
            [
                'itemNumber' => '442345522',
                'estimated' => 2,
            ],
        ],
    ]
);

Létrehozunk egy tömböt, ami tartalmazza a módosítandó beszállítás azon adatait, amiket módosítani szeretnénk. Ezt a json_encode() függvény segítségével átalakítjuk egy JSON formátumú string-re, amit eltárolunk a $editedShipmentJson változóban.

A beszállítás módosításához szükséges PATCH üzenet elküldése:

$response = $client->patch('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
        'Content-Type' => 'application/json',
    ],
    'body' => $editedShipmentJson,
]);

A GuzzleHttp\Client típusú $client, patch() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a módosítani kívánt beszállítás azonosítója, amit a példában a $shipmentId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében a HTTP fejléc adatai, a body indexű elemében pedig az üzenet body-ja található, amit a már korábban létrehozott $editedShipmentJson változó tartalmaz.

A HTTP fejléc adatai egy tömbben vannak, melynek az Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval, a Content-Type indexű eleme pedig meghatározza, hogy a kérés body-ja JSON formátumú.

Az API által küldött válasz feldolgozása:

 $editedShipmentId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a módosított beszállítás azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Beszállítás lekérdezése azonosító alapján

Egy beszállítás lekérdezéséhez az /inward-handling/{id} címre kell küldeni egy GET kérést, ahol a címben szereplő {id} helyére kell beilleszteni a lekérdezni kívánt beszállítás azonosítóját (id).

Példa:

$client = new GuzzleHttp\Client();

$shipmentId = 1;

try {
    $response = $client->get('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $shipment = json_decode(
        $response->getBody()->getContents()
    );
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

GET üzenet elküldése a beszállítás lekérdezéséhez:

$response = $client->get('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, get() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a lekérdezni kívánt beszállítás azonosítója, amit a példában az $shipmentId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API által küldött válasz feldolgozása:

$shipment = json_decode(
    $response->getBody()->getContents()
);

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum tartalmazza a lekérdezett beszállítást.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.

Beszállítás törlése

Egy beszállítás törléséhez az /inward-handling/{id} címre kell küldeni egy DELETE kérést, ahol a címben szereplő {id} helyére kell beilleszteni a törölni kívánt beszállítás azonosítóját (id).

Példa:

$client = new GuzzleHttp\Client();

$shipmentId = 1;

try {
    $response = $client->delete('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
        'headers' => [
            'Authorization' => 'Bearer ' . $token,
        ]
    ]);

    $statusCode = $response->getStatusCode();
    $deletedShipmentId = json_decode(
        $response->getBody()->getContents()
    )->id;
} catch (GuzzleHttp\Exception\RequestException $exception) {
    $statusCode = $exception->getCode();
    $errorMessage = json_decode(
        $exception->getResponse()->getBody()->getContents()
    )->error;
}

DELETE üzenet elküldése a beszállítás törléséhez:

$response = $client->delete('https://devapi.ilogistic.eu/inward-handling/' . $shipmentId, [
    'headers' => [
        'Authorization' => 'Bearer ' . $token,
    ]
]);

A GuzzleHttp\Client típusú $client, delete() függvényével elküldünk egy kérést. A függvény első paraméterében megadjuk az API végpont elérési útvonalát, aminek a végén szerepel a törölni kívánt megrendelés azonosítója, amit a példában az $shipmentId változó tartalmaz. A második paraméterében egy tömböt adunk meg, melynek a headers indexű elemében található tömb tartalmazza a HTTP fejléc adatait. A tömb Authorization indexű eleme tartalmazza a token típusát jelző "Bearer " stringet összefűzve az autentikációhoz szükséges tokent tartalmazó $token változóval.

Az API által küldött válasz feldolgozása:

$deletedShipmentId = json_decode(
    $response->getBody()->getContents()
)->id;

A kérésre kapott választ tartalmazó Psr\Http\Message\ResponseInterface típusú $response változó getBody() függvényének visszatérési értéke \Psr\Http\Message\StreamInterface típusú, aminek a getContents() függvényével megkapjuk az API által küldött válasz body-ját string-ként. Ez a string json formátumú, amit a json_decode() függvény segítségével tudunk feldolgozni. Az így kapott objektum id tulajdonsága tartalmazza a törölt beszállítás azonosítóját.

Az API által adott válasz, HTTP státuszkódjának lekérdezése és a hibakezelés már részletesen bemutatásra került a Bejelentkezés e-mail címmel és jelszóval fejezetben.