dynamic / silverstripe-salsify

src/Model/Fetcher.php

<?php

namespace Dynamic\Salsify\Model;

use Exception;
use GuzzleHttp\Client;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;

/**
 * Class Importer
 * @package Dynamic\Salsify\Model
 *
 * Based off https://github.com/XinV/salsify-php-api/blob/master/lib/Salsify/API.php
 */
class Fetcher extends Service
{

    /**
     * @var string
     */
    const API_BASE_URL = 'https://app.salsify.com/api/';

    /**
     * @var string
     */
    protected $channelRunID;

    /**
     * @var string
     */
    protected $channelRunDataUrl;

    /**
     * Importer constructor.
     * @param string $importerKey
     * @param bool $noChannel
     * @throws \Exception
     */
    public function __construct($importerKey, $noChannel = false)
    {
        parent::__construct($importerKey);

$importerKey of type string is incompatible with the type Dynamic\Salsify\Model\stirng expected by parameter $importerKey of Dynamic\Salsify\Model\Service::__construct().

        if (!$this->config()->get('apiKey')) {
            throw new Exception('An API key needs to be provided');
        }

        if ($noChannel === false && !$this->config()->get('channel')) {
            throw new Exception('A fetcher needs a channel');
        }
    }

    /**
     * @return string
     */
    private function channelUrl()
    {
        $channel = $this->config()->get('channel');
        if ($organization = $this->config()->get('organizationID')) {
            return "orgs/{$organization}/channels/{$channel}";
        }
        return "channels/{$channel}";
    }

    /**
     * @return string
     */
    private function channelRunsBaseUrl()
    {
        return $this->channelUrl() . '/runs';
    }

    /**
     * @return string
     */
    private function createChannelRunUrl()
    {
        return $this->channelRunsBaseUrl();
    }

    /**
     * @return string
     */
    private function channelRunUrl()
    {
        if ($this->config()->get('useLatest')) {
            return $this->channelRunsBaseUrl() . '/latest';
        }
        return $this->channelRunsBaseUrl() . '/' . $this->channelRunID;
    }

    /**
     * @param string $url
     * @param string $method
     * @param string|null $postBody
     * @return array|string
     *
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    private function salsifyRequest($url, $method = 'GET', $postBody = null)
    {
        $client = new Client([
            'base_uri' => self::API_BASE_URL,
            'timeout' => $this->config()->get('timeout'),
            'http_errors' => false,
            'verify' => true,
            'headers' => [
                'Authorization' => 'Bearer ' . $this->config()->get('apiKey'),
                'Content-Type' => 'application/json',
            ],
        ]);

        if ($method === 'POST' && is_array($postBody)) {

The condition is_array($postBody) is always false.

            $response = $client->request($method, $url, [
                'json' => $postBody,
            ]);
        } else {
            $response = $client->request($method, $url);
        }


        if ($response->getStatusCode() === 404) {
            throw new Exception("Endpoint wasn't found. Are you sure the channel and organization are correct?");
        }

        if ($response->getBody() && !empty($response->getBody())) {
            $response = json_decode($response->getBody(), true);

            // throw exceptions for salsify errors
            if (array_key_exists('errors', $response)) {
                foreach ($this->yieldSingle($response['errors']) as $error) {
                    throw new Exception($error);
                }
            }
        }

        return $response;

The expression return $response also could return the type Psr\Http\Message\ResponseInterface which is incompatible with the documented return type array|string.

    }

    /**
     * @return $this
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function startExportRun()
    {
        if ($this->config()->get('useLatest') !== true) {
            $response = $this->salsifyRequest($this->createChannelRunUrl(), 'POST');
            $this->channelRunID = $response['id'];
        }
        return $this;
    }

    /**
     * @throws \GuzzleHttp\Exception\GuzzleException
     * @throws \Exception
     */
    private function checkExportUrl()
    {
        $exportRun = $this->salsifyRequest($this->channelRunUrl());
        $status = $exportRun['status'];
        if ($status === 'completed') {
            $this->channelRunDataUrl = $exportRun['product_export_url'];
        } elseif ($status === 'failed') {
            // this would be an internal error in Salsify
            throw new Exception('Salsify failed to produce an export.');
        }
    }

    /**
     * waits until salsify is done preparing the given export, and returns the URL when done.
     * Throws an exception if anything funky occurs.
     *
     * @return $this
     * @throws \Exception
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function waitForExportRunToComplete()
    {
        $this->channelRunDataUrl = null;
        do {
            $this->checkExportUrl();
            sleep(5);
        } while (!$this->channelRunDataUrl);
        return $this;
    }

    /**
     * @return string
     */
    public function getExportUrl()
    {
        return $this->channelRunDataUrl;
    }
}