Fetcher::setUseLatest() - Code Metrics - Inspection of "Task now allows multiple fetchers and mappers" - dynamic/silverstripe-salsify - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#13)

by Matthew
created 2019-07-18 22:18 UTC
Fetcher::setUseLatest() A

↳ Parent: Fetcher
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	4
rs	10
<?php

namespace Dynamic\Salsify\Model;

use Exception;
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
{
    use Configurable;
    use Extensible;
    use Injectable;

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

    /**
     * @var array
     */
    protected $config;

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

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

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

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

    /**
     * @var bool
     */
    protected $useLatest = false;

    /**
     * @var int
     */
    protected $timeout;

    /**
     * Importer constructor.
     * @param string|int $channelID
     * @param bool $useLatest
     */
    public function __construct($config)
    {
        $this->config = $config;

        if (array_key_exists('channel', $this->config) && $config['channel']) {
            $this->setChannelID($config['channel']);
        }

        if (array_key_exists('useLatest', $this->config) && $config['useLatest']) {
            $this->setUseLatest((bool)$config['useLatest']);
        }

        $this->setTimeout();
    }

    /**
     * @return string
     */
    public function getApiKey()
    {
        if (!$this->apiKey) {
            $this->setApiKey();
        }

        if (!$this->apiKey) {
            throw new Exception('No api key provided');
        }
        return $this->apiKey;
    }

    /**
     * Sets the api key
     */
    public function setApiKey()
    {
        $this->apiKey = $this->config()->get('apiKey');
        if (array_key_exists('apiKey', $this->config) && $this->config['apiKey']) {
            $this->apiKey = $this->config['apiKey'];
        }
    }

    /**
     * @return int
     */
    public function getTimeout()
    {
        if (!$this->timeout) {
            $this->setTimeout();
        }

        return $this->timeout;
    }

    /**
     * @param int $timeout
     */
    public function setTimeout($timeout = 0)
    {
        if (10 <= $timeout) {
            $this->timeout = $timeout;
            return;
        }

        $this->timeout = $this->config()->get('timeout');
        if (array_key_exists('timeout', $this->config) && $this->config['timeout']) {
            $this->timeout = $this->config['timeout'];
        }
    }

    /**
     * @param string|int $channelID
     * @return $this
     */
    public function setChannelID($channelID)
    {
        $this->channelID = $channelID;
        return $this;
    }

    /**
     * @param bool useLatest
filter:
    dependency_paths: ["lib/*"]
     * @return $this
     */
    public function setUseLatest($useLatest)
    {
        $this->useLatest = $useLatest;
        return $this;
    }

    /**
     * @return string
     */
    private function channelUrl()
    {
        return self::API_BASE_URL . 'channels/' . $this->channelID;
    }

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

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

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

    /**
     * @return string
     * @throws \Exception
     */
    private function apiUrlSuffix()
    {
        return '?format=json&auth_token=' . $this->getApiKey();
    }

    /**
     * @param string $url
     * @param string $method
     * @param string|null $postBody
     * @return array|string
     *
     * @throws \Exception
     */
    private function salsifyRequest($url, $method = 'GET', $postBody = null)
    {
        $defaultCurlOptions = array(
            CURLOPT_URL => $url . $this->apiUrlSuffix(),
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HEADER => false,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => array('Content-Type: application/json'),
            // seemed reasonable settings
            CURLOPT_TIMEOUT => $this->getTimeout(),
            CURLOPT_FRESH_CONNECT => true,
            CURLOPT_FORBID_REUSE => true,
        );
        if ($method === 'POST' && is_array($postBody)) {

            $postBody = json_encode($postBody);

        }
        $ch = curl_init($url);
        curl_setopt_array($ch, $defaultCurlOptions);
        curl_setopt_array(/** @scrutinizer ignore-type */ $ch, $defaultCurlOptions);
        $response = curl_exec($ch);
        $response = curl_exec(/** @scrutinizer ignore-type */ $ch);
        $httpStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $httpStatus = curl_getinfo(/** @scrutinizer ignore-type */ $ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        curl_close(/** @scrutinizer ignore-type */ $ch);
        if ($response && !empty($response)) {
            $response = json_decode($response, true);
            $response = json_decode(/** @scrutinizer ignore-type */ $response, true);
        }
        return $response;
    }

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

    /**
     * @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
     */
    public function waitForExportRunToComplete()
    {
        $this->channelRunDataUrl = null;
        do {
            $this->checkExportUrl();
            sleep(5);
        } while (!$this->channelRunDataUrl);
        return $this;
    }

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

dynamic / silverstripe-salsify

Pull Request — master (#13)

Fetcher::setUseLatest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
