CybozuHttp\Config

Complexity

Total Complexity

35

Size/Duplication

Total Lines	226
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	configureDefaults()	0	6	1
A	configureAuth()	0	9	2
A	configureBasicAuth()	0	6	2
A	configureCert()	0	9	2
A	getBasicAuthOptions()	0	10	2
A	getCertOptions()	0	10	2
A	toArray()	0	4	1
A	get()	0	8	2
B	hasRequired()	0	13	6
A	hasRequiredOnAuth()	0	8	3
A	hasRequiredOnBasicAuth()	0	4	1
A	hasRequiredOnCert()	0	4	1
A	hasRequiredOnCache()	0	4	1
B	hasKeysByUse()	0	14	5
A	getBaseUrl()	0	15	3

<?php

namespace CybozuHttp;

use CybozuHttp\Exception\NotExistRequiredException;


/**
 * @author ochi51 <ochiai07@gmail.com>
 */
class Config
{

    /**
     * @var array $config
     */
    private $config = [];

    /**
     * @var array $default
     */
    private $default = [
        'domain' => "cybozu.com",
        'use_api_token' => false,
        'use_basic' => false,
        'use_client_cert' => false,
        'base_url' => null,
        'defaults' => [],
        'use_cache' => false,
        'cache_dir' => null,
        'cache_ttl' => 0,
        'debug' => false
    ];

    /**
     * @var array $required
     */
    private $required = [
        'domain',
        'subdomain',
        'use_api_token',
        'use_basic',
        'use_client_cert',
        'base_url',
        'defaults',
        'use_cache',
        'debug'
    ];

    public function __construct(array $config)
    {
        $this->config = $config + $this->default;

        $this->config['base_url'] = $this->getBaseUrl();

        $this->configureDefaults();
    }

    /**
     * configure default options
     */
    private function configureDefaults()
    {
        $this->configureAuth();
        $this->configureBasicAuth();
        $this->configureCert();
    }

    private function configureAuth()
    {
        if ($this->get('use_api_token')) {
            $this->config['defaults']['headers']['X-Cybozu-API-Token'] = $this->get('token');
        } else {
            $this->config['defaults']['headers']['X-Cybozu-Authorization'] =
                base64_encode($this->get('login') . ':' . $this->get('password'));
        }
    }

    private function configureBasicAuth()
    {
        if ($this->get('use_basic')) {
            $this->config['defaults']['auth'] = $this->getBasicAuthOptions();
        }
    }

    private function configureCert()
    {
        if ($this->get('use_client_cert')) {
            $this->config['defaults']['verify'] = true;
            $this->config['defaults']['cert'] = $this->getCertOptions();
        } else {
            $this->config['defaults']['verify'] = false;
        }
    }

    /**
     * @return array
     */
    private function getBasicAuthOptions()
    {
        if ($this->hasRequiredOnBasicAuth()) {
            return [
                $this->get('basic_login'),
                $this->get('basic_password')
            ];
        }
        throw new NotExistRequiredException("kintone.empty_basic_password");
    }

    /**
     * @return array
     */
    private function getCertOptions()
    {
        if ($this->hasRequiredOnCert()) {
            return [
                $this->get('cert_file'),
                $this->get('cert_password')
            ];
        }
        throw new NotExistRequiredException("kintone.empty_cert");
    }

    /**
     * @return array
     */
    public function toArray()
    {
        return $this->config;
    }

    /**
     * @param $key
     * @return string|bool
     */
    public function get($key)
    {
        if (isset($this->config[$key])) {
            return $this->config[$key];
        }

        return false;
    }

    /**
     * @return bool
     */
    public function hasRequired()
    {
        foreach ($this->required as $r) {
            if (!array_key_exists($r, $this->config)) {
                return false;
            }
        }

        return $this->hasRequiredOnAuth()
                && $this->hasRequiredOnBasicAuth()
                && $this->hasRequiredOnCert()
                && $this->hasRequiredOnCache();
    }

    /**
     * @return bool
     */
    private function hasRequiredOnAuth()
    {
        if ($this->get('use_api_token')) {
            return !empty($this->get('token'));
        }

        return $this->get('login') && $this->get('password');
    }

    /**
     * @return bool
     */
    private function hasRequiredOnBasicAuth()
    {
        return $this->hasKeysByUse('use_basic', ['basic_login', 'basic_password']);
    }

    /**
     * @return bool
     */
    private function hasRequiredOnCert()
    {
        return $this->hasKeysByUse('use_client_cert', ['cert_file', 'cert_password']);
    }

    /**
     * @return bool
     */
    private function hasRequiredOnCache()
    {
        return $this->hasKeysByUse('use_cache', ['cache_dir', 'cache_ttl']);
    }

    /**
     * @param string $use
     * @param string[] $keys
     * @return bool
     */
    private function hasKeysByUse($use, array $keys)
    {
        if (!$this->get($use)) {
            return true;
        }

        foreach ($keys as $key) {
            if (is_null($this->get($key)) || $this->get($key) === false) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return string
     */
    public function getBaseUrl()
    {
        $subdomain = $this->get('subdomain');
        $uri = "https://" . $subdomain;

        if (strpos($subdomain, '.') === false) {
            if ($this->get('use_client_cert')) {
                $uri .= ".s";
            }

            $uri .= "." . $this->get('domain');
        }

        return $uri;
    }
}