Tomaj\NetteApi\Misc\ConsoleRequest

Complexity

Total Complexity

23

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

70.1%

Importance

Changes	8
Bugs	2	Features	3

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	makeRequest()	0	61	7
C	processValues()	0	32	7
B	processParam()	0	23	6
A	processMultiParam()	0	10	2

<?php

namespace Tomaj\NetteApi\Misc;

use Tomaj\NetteApi\Handlers\ApiHandlerInterface;
use Tomaj\NetteApi\Params\InputParam;

class ConsoleRequest
{
    /**
     * @var ApiHandlerInterface
     */
    private $handler;

    /**
     * Create ConsoleRequest
     *
     * @param ApiHandlerInterface $handler
     */
    public function __construct(ApiHandlerInterface $handler)
    {
        $this->handler = $handler;
    }

    /**
     * Make request to API url
     *
     * @param string $url
     * @param string $method
     * @param array $values
     * @param string|null $token
     *
     * @return ConsoleResponse
     */
    public function makeRequest($url, $method, array $values, $token = null)
    {
        list($postFields, $getFields) = $this->processValues($values);

        if (count($getFields)) {
            $parts = [];
            foreach ($getFields as $key => $value) {
                $parts[] = "$key=$value";
            }
            $url = $url . '?' . implode('&', $parts);
        }

        $startTime = microtime();

        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL, $url);
        curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
        curl_setopt($curl, CURLOPT_NOBODY, false);
        curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_VERBOSE, false);
        curl_setopt($curl, CURLOPT_TIMEOUT, 10);
        curl_setopt($curl, CURLOPT_HEADER, 1);
        if (count($postFields)) {
            curl_setopt($curl, CURLOPT_POST, 1);
            curl_setopt($curl, CURLOPT_POSTFIELDS, $postFields);
        }

        curl_setopt($curl, CURLOPT_TIMEOUT, 30);
        $headers = [];
        if ($token !== null && $token !== false) {
            $headers = ['Authorization: Bearer ' . $token];
            curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
        }

        $consoleResponse = new ConsoleResponse(
            $url,
            $method,
            $postFields,
            $getFields,
            $headers
        );

        $response = curl_exec($curl);
        $elapsed = intval((microtime() - $startTime) * 1000);

        $headerSize = curl_getinfo($curl, CURLINFO_HEADER_SIZE);
        $responseHeaders = substr($response, 0, $headerSize);
        $responseBody = substr($response, $headerSize);

        $curlErrorNumber = curl_errno($curl);
        $curlError = curl_error($curl);
        if ($curlErrorNumber > 0) {
            $consoleResponse->logError($curlErrorNumber, $curlError, $elapsed);
        } else {
            $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
            $consoleResponse->logRequest($httpCode, $responseBody, $responseHeaders, $elapsed);
        }

        return $consoleResponse;
    }

    /**
     * Process given values to POST and GET fields
     *
     * @param array $values
     *
     * @return array
     */
    private function processValues(array $values)
    {
        $params = $this->handler->params();

        $postFields = [];
        $getFields = [];
        $fileFields = [];

        foreach ($values as $key => $value) {
            if (strstr($key, '___') !== false) {
                $parts = explode('___', $key);
                $key = $parts[0];
            }

            foreach ($params as $param) {
                $valueData = $this->processParam($param, $key, $value);
                if ($valueData === null) {
                    continue;
                }

                if ($param->getType() == InputParam::TYPE_FILE) {
                    $postFields[$key] = $valueData;
                } elseif ($param->getType() == InputParam::TYPE_POST) {
                    $postFields[$key] = $valueData;
                } else {
                    $getFields[$key] = $valueData;
                }
            }
        }

        return [$postFields, $getFields, $fileFields];
    }

    /**
     * Process one param and returns value
     *
     * @param InputParam  $param   input param
     * @param string      $key     param key
     * @param string      $value   actual value from request
     *
     * @return string
     */
    private function processParam(InputParam $param, $key, $value)
    {
        if ($param->getKey() == $key) {
            if (!$value) {
                return null;
            }

            if ($param->isMulti()) {
                $valueData = $this->processMultiParam($key, $value);
            } elseif ($param->getType() == InputParam::TYPE_FILE) {
                if ($value->isOk()) {

The method isOk cannot be called on $value (of type string).

                    $valueData = curl_file_create($value->getTemporaryFile(), $value->getContentType(), $value->getName());

The method getTemporaryFile cannot be called on $value (of type string).

The method getContentType cannot be called on $value (of type string).

The method getName cannot be called on $value (of type string).

                } else {
                    $valueData = false;
                }
            } else {
                $valueData = "$value";
            }

            return $valueData;
        }
        return null;
    }

    /**
     * Process multi param
     *
     * @param string  $key
     * @param string  $value
     * @return string
     */
    private function processMultiParam($key, $value)
    {
        $valueKey = '';
        if (strstr($value, '=') !== false) {
            $parts = explode('=', $value);
            $valueKey = $parts[0];
            $value = $parts[1];
        }
        return $key . "[$valueKey]=$value";
    }
}