Client::transformMultipartUploadData() - Code Metrics - Inspection of "修复文件上传时提交数组数据的 bug" - overtrue/http - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#14)

by xu
created 2019-08-09 09:02 UTC
Client::transformMultipartUploadData() A

↳ Parent: Client
Complexity

Conditions	4
Paths	4
Size

Total Lines	23
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Importance

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

/*
 * This file is part of the overtrue/http.
 *
 * (c) overtrue <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Overtrue\Http;

use GuzzleHttp\Client as GuzzleClient;
use Overtrue\Http\Traits\HasHttpRequests;

/**
 * Class BaseClient.
 *
 * @author overtrue <[email protected]>
 */
class Client
{
    use HasHttpRequests {
        request as performRequest;
    }

    /**
     * @var \Overtrue\Http\Config
     */
    protected $config;

    /**
     * @var
     */
    protected $baseUri;

    /**
     * @return static
     */
    public static function create(): self
    {
        return new static(...func_get_args());
        return new static(/** @scrutinizer ignore-type */ ...func_get_args());
    }

    /**
     * Client constructor.
     *
     * @param \Overtrue\Http\Config|array $config
     */
    public function __construct($config = [])
    {
        $this->config = $this->normalizeConfig($config);
    }

    /**
     * GET request.
     *
     * @param string $url
     * @param array  $query
     *
     * @return \Psr\Http\Message\ResponseInterface|\Overtrue\Http\Support\Collection|array|object|string
     */
    public function get(string $url, array $query = [])
    {
        return $this->request($url, 'GET', ['query' => $query]);
    }

    /**
     * POST request.
     *
     * @param string $url
     * @param array  $data
     *
     * @return \Psr\Http\Message\ResponseInterface|\Overtrue\Http\Support\Collection|array|object|string
     */
    public function post(string $url, array $data = [])
    {
        return $this->request($url, 'POST', ['form_params' => $data]);
    }

    /**
     * JSON request.
     *
     * @param string       $url
     * @param string|array $data
     * @param array        $query
     *
     * @return \Psr\Http\Message\ResponseInterface|\Overtrue\Http\Support\Collection|array|object|string
     */
    public function postJson(string $url, array $data = [], array $query = [])
    {
        return $this->request($url, 'POST', ['query' => $query, 'json' => $data]);
    }

    /**
     * Upload file.
     *
     * @param string $url
     * @param array  $files
     * @param array  $form
     * @param array  $query
     *
     * @return \Psr\Http\Message\ResponseInterface|\Overtrue\Http\Support\Collection|array|object|string
     */
    public function upload(string $url, array $files = [], array $form = [], array $query = [])
    {
        $multipart = [];

        foreach ($files as $name => $path) {
            $multipart[] = [
                'name' => $name,
                'contents' => fopen($path, 'r'),
            ];
        }

        foreach ($form as $name => $contents) {
            $multipart = array_merge($multipart, $this->transformMultipartUploadData($name, $contents));
        }

        return $this->request($url, 'POST', ['query' => $query, 'multipart' => $multipart]);
    }

    /**
     * @param string $uri
     * @param string $method
     * @param array  $options
     * @param bool   $returnRaw
     *
     * @return \Psr\Http\Message\ResponseInterface|\Overtrue\Http\Support\Collection|array|object|string
     */
    public function request(string $uri, string $method = 'GET', array $options = [], $returnRaw = false)
    {
        if (property_exists($this, 'baseUri') && !is_null($this->baseUri)) {
            $options['base_uri'] = $this->baseUri;
        }

        if ((!empty($options['base_uri']) || $this->config->getBaseUri()) && $this->config->needAutoTrimEndpointSlash()) {
            $uri = ltrim($uri, '/');
        }

        $response = $this->performRequest($uri, $method, $options);

        return $this->castResponseToType(
            $response,
            $returnRaw ? 'raw' : $this->config->getOption('response_type')
        );
    }

    /**
     * @param string $url
     * @param string $method
     * @param array  $options
     *
     * @return \Overtrue\Http\Responses\Response
     */
    public function requestRaw(string $url, string $method = 'GET', array $options = [])
    {
        return $this->request($url, $method, $options, true);

    }

    /**
     * Return GuzzleHttp\Client instance.
     *
     * @return \GuzzleHttp\ClientInterface
     */
    public function getHttpClient(): \GuzzleHttp\ClientInterface
    {
        if (!$this->httpClient) {
            $this->httpClient = new GuzzleClient($this->config->toArray());
        }

        return $this->httpClient;
    }

    /**
     * @return \Overtrue\Http\Config
     */
    public function getConfig(): \Overtrue\Http\Config
    {
        return $this->config;
    }

    /**
     * @param \Overtrue\Http\Config $config
     *
     * @return \Overtrue\Http\Client
     */
    public function setConfig(\Overtrue\Http\Config $config): \Overtrue\Http\Client
    {
        $this->config = $config;

        return $this;
    }

    /**
     * Transform Multipart Upload Data.
     *
     * @param string|int         $name
     * @param string|array|mixed $contents
     *
     * @return array
     */
    protected function transformMultipartUploadData($name, $contents)
    {
        if (!is_array($contents)) {
            return [[
                'name' => $name,
                'contents' => $contents,
            ]];
        }

        $datas = [];
        foreach ($contents as $key => $value) {
            $key = $name.'['.$key.']';
            if (is_array($value)) {
                $datas = array_merge($datas, $this->transformMultipartUploadData($key, $value));
            } else {
                $datas[] = [
                    'name' => $key,
                    'contents' => $value,
                ];
            }
        }

        return $datas;
    }

    /**
     * @param mixed $config
     *
     * @return \Overtrue\Http\Config
     */
    protected function normalizeConfig($config): \Overtrue\Http\Config
    {
        if (\is_array($config)) {
            $config = new Config($config);
        }

        if (!($config instanceof Config)) {
            throw new \InvalidArgumentException('config must be array or instance of Overtrue\Http\Config.');
        }

        return $config;
    }
}

overtrue / http

Pull Request — master (#14)

Client::transformMultipartUploadData() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
