Quandl::__construct() - Code Metrics - royopa/quandl-elephant-api - Measure and Improve Code Quality continuously with Scrutinizer

Quandl::__construct() A
last analyzed 2016-03-12 22:04 UTC

↳ Parent: Quandl

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
ccs	4
cts	4
cp	1
rs	9.4285
cc	1
eloc	3
nc	1
nop	2
crap	1

<?php

namespace Royopa\Quandl;

class Quandl
{
    public $api_key       = null;
    public $format        = null;
    public $cache_handler = null;
    public $was_cached    = false;
    public $force_curl    = false;
    public $no_ssl_verify = false; // disable ssl verification for curl
    public $last_url      = null;
    public $error         = null;

    private static $url_templates = [
        "symbol"  => 'https://www.quandl.com/api/v1/datasets/%s.%s?%s',
        "search"  => 'https://www.quandl.com/api/v1/datasets.%s?%s',
        "list"    => 'https://www.quandl.com/api/v2/datasets.%s?%s',
    ];
    
    public function __construct($api_key = null, $format = 'object')
    {
        $this->api_key = $api_key;
        $this->format  = $format;
    }

    // getSymbol returns data for a given symbol.
    public function getSymbol($symbol, $params = null)
    {
        $url = $this->getUrl(
            'symbol',
            $symbol,
            $this->getFormat(),
            $this->arrangeParams($params)
        );

        return $this->getData($url);
    }

    // getSearch returns results for a search query.
    // CSV output is not supported with this node so if format
    // is set to CSV, the result will fall back to object mode.
    public function getSearch($query, $page = 1, $per_page = 300)
    {
        $params = $this->constructParams($query, $page, $per_page);
        $url    = $this->generateUrl('search', true, $params);

        return $this->getData($url);
    }

    // getList returns the list of symbols for a given source.
    public function getList($query, $page = 1, $per_page = 300)
    {
        $params          = $this->constructParams($query, $page, $per_page);
        $params["query"] = "*";
        $url             = $this->generateUrl('list', false, $params);

        return $this->getData($url);
    }

    //generate the url basead in parameters
    public function generateUrl($type = '', $format = false, $params)
    {
        $url = $this->getUrl(
            $type,
            $this->getFormat($format),
            $this->arrangeParams($params)
        );

        return $url;
    }

    // getFormat returns one of the three formats supported by Quandl.
    // It is here for two reasons: 
    //  1) we also allow 'object' format. this will be sent to Quandl
    //     as "json" but the getData method will return a json_decoded
    //     output.
    //  2) some Quandl nodes do not support CSV (namely search).
    private function getFormat($omit_csv = false)
    {
        if (($this->format == 'csv' && $omit_csv) || $this->format == 'object') {
            return 'json';
        }

        return $this->format;
    }

    // getUrl receives a kind that points to a URL template and 
    // a variable number of parameters, which will be replaced
    // in the template.
    /**
     * @param string $kind
     */
    private function getUrl($kind)
    {
        $template       = self::$url_templates[$kind];
        $args           = array_slice(func_get_args(), 1);
        $this->last_url = trim(vsprintf($template, $args), '?&');
        
        return $this->last_url;
    }

    // getData executes the download operation and returns the result
    // as is, or json-decoded if 'object' type was requested.
    /**
     * @param string $url
     */
    private function getData($url)
    {
        $result = $this->executeDownload($url);
        
        if ($this->format == 'object') {
            return json_decode($result);
        }

        return $result;
    }

    // executeDownload gets a URL, and returns the downloaded document
    // either from cache (if cache_handler is set) or from Quandl.
    private function executeDownload($url)
    {
        if (! $this->cache_handler) {
            $data = $this->download($url);
            return $data;
        }
        
        $data = $this->attemptGetFromCache($url);

        if (!$data) {
            throw new \Exception('Error in download document');
        }

        return $data;
    }

    // attemptGetFromCache is called if a cache_handler is available.
    // It will call the cache handler with a get request, return the 
    // document if found, and will ask it to store the downloaded 
    // object where applicable.
    private function attemptGetFromCache($url)
    {
        $this->was_cached = false;
        $data = call_user_func($this->cache_handler, 'get', $url);
        
        if ($data) {
            $this->was_cached = true;
            return $data;
        }

        $data = $this->download($url);
        
        if ($data) {
            call_user_func($this->cache_handler, 'set', $url, $data);
        }

        return $data;
    }

    // arrangeParams converts a parameters array to a query string.
    // In addition, we add some patches:
    //  1) trim_start and trim_end are converted from any plain
    //     language syntax to Quandl format
    //  2) api_key is appended
    private function arrangeParams($params)
    {
        if ($this->api_key) {
            $params['auth_token'] = $this->api_key;
        }
        
        if (!$params) {
            return $params;   
        }
        
        foreach (['trim_start', 'trim_end'] as $v) {
            if (isset($params[$v])) {
                $params[$v] = self::convertToQuandlDate($params[$v]);
            }
        }
        
        return http_build_query($params);
    }

    // convertToQuandlDate converts any time string supported by
    // PHP (e.g. "today-30 days") to the format needed by Quandl
    private static function convertToQuandlDate($time_str)
    {
        return date('Y-m-d', strtotime($time_str));
    }

    /*
     * download fetches url with file_get_contents or curl fallback
     * You can force curl download by setting force_curl to true.
     * You can disable SSL verification for curl by setting 
     * no_ssl_verify to true (solves "SSL certificate problem")
     */
    private function download($url)
    {
        if (! $this->checkUrl($url)) {
            return false;
        }
        
        if (ini_get('allow_url_fopen') && !$this->force_curl) {
            return $this->getDataWithFileGetContents($url);
        }

        if (!function_exists('curl_version')) {
            $this->error = 'Enable allow_url_fopen or curl';
            return false;
        }

        return $this->getDataWithCurl($url);
    }

    //check url
    private function checkUrl($url)
    {
        $headers_url = get_headers($url);
        $http_code   = $headers_url[0];

        if (strpos($http_code, '404') !== false) {
            $this->error = 'URL not found or invalid URL';
            return false;
        }

        return true;
    }

    //download data with file_get_contents PHP function
    private function getDataWithFileGetContents($url)
    {
        try {
            return file_get_contents($url);
        } catch (\Exception $e) {
            $this->error = $e->getMessage();
        }
    }

    //download data with file_get_contents PHP function
    private function getDataWithCurl($url)
    {
        $curl = curl_init();
            
        curl_setopt($curl, CURLOPT_URL, $url);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);

        // disable ssl verification for curl
        if ($this->no_ssl_verify) {
            curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0);
        }
           
        $data  = curl_exec($curl);
        $error = curl_error($curl);

        curl_close($curl);

        if (! $error) {
            return $data;
        }
        
        $this->error = $error;
        
        return false;
    }

    //construct a array with parameters used to query
    private function constructParams($query, $page = 1, $per_page = 300)
    {
        $params = [
            "per_page" => $per_page, 
            "page"     => $page, 
            "query"    => $query,
        ];

        return $params;
    }
}


1		<?php
2
3		namespace Royopa\Quandl;
4
5		class Quandl
6		{
7		public $api_key = null;
8		public $format = null;
9		public $cache_handler = null;
10		public $was_cached = false;
11		public $force_curl = false;
12		public $no_ssl_verify = false; // disable ssl verification for curl
13		public $last_url = null;
14		public $error = null;
15
16		private static $url_templates = [
17		"symbol" => 'https://www.quandl.com/api/v1/datasets/%s.%s?%s',
18		"search" => 'https://www.quandl.com/api/v1/datasets.%s?%s',
19		"list" => 'https://www.quandl.com/api/v2/datasets.%s?%s',
20		];
21
22	8	public function __construct($api_key = null, $format = 'object')
23		{
24	8	$this->api_key = $api_key;
25	8	$this->format = $format;
26	8	}
27
28		// getSymbol returns data for a given symbol.
29	8	public function getSymbol($symbol, $params = null)
30		{
31	8	$url = $this->getUrl(
32	8	'symbol',
33	8	$symbol,
34	8	$this->getFormat(),
35	8	$this->arrangeParams($params)
36	8	);
37
38	8	return $this->getData($url);
39		}
40
41		// getSearch returns results for a search query.
42		// CSV output is not supported with this node so if format
43		// is set to CSV, the result will fall back to object mode.
44		public function getSearch($query, $page = 1, $per_page = 300)
45		{
46		$params = $this->constructParams($query, $page, $per_page);
47		$url = $this->generateUrl('search', true, $params);
48
49		return $this->getData($url);
50		}
51
52		// getList returns the list of symbols for a given source.
53		public function getList($query, $page = 1, $per_page = 300)
54		{
55		$params = $this->constructParams($query, $page, $per_page);
56		$params["query"] = "*";
57		$url = $this->generateUrl('list', false, $params);
58
59		return $this->getData($url);
60		}
61
62		//generate the url basead in parameters
63		public function generateUrl($type = '', $format = false, $params)
64		{
65		$url = $this->getUrl(
66		$type,
67		$this->getFormat($format),
68		$this->arrangeParams($params)
69		);
70
71		return $url;
72		}
73
74		// getFormat returns one of the three formats supported by Quandl.
75		// It is here for two reasons:
76		// 1) we also allow 'object' format. this will be sent to Quandl
77		// as "json" but the getData method will return a json_decoded
78		// output.
79		// 2) some Quandl nodes do not support CSV (namely search).
80	8	private function getFormat($omit_csv = false)
81		{
82	8	if (($this->format == 'csv' && $omit_csv) \|\| $this->format == 'object') {
83	4	return 'json';
84		}
85
86	4	return $this->format;
87		}
88
89		// getUrl receives a kind that points to a URL template and
90		// a variable number of parameters, which will be replaced
91		// in the template.
92		/**
93		* @param string $kind
94		*/
95	8	private function getUrl($kind)
96		{
97	8	$template = self::$url_templates[$kind];
98	8	$args = array_slice(func_get_args(), 1);
99	8	$this->last_url = trim(vsprintf($template, $args), '?&');
100
101	8	return $this->last_url;
102		}
103
104		// getData executes the download operation and returns the result
105		// as is, or json-decoded if 'object' type was requested.
106		/**
107		* @param string $url
108		*/
109	8	private function getData($url)
110		{
111	8	$result = $this->executeDownload($url);
112
113	7	if ($this->format == 'object') {
114	3	return json_decode($result);
115		}
116
117	4	return $result;
118		}
119
120		// executeDownload gets a URL, and returns the downloaded document
121		// either from cache (if cache_handler is set) or from Quandl.
122	8	private function executeDownload($url)
123		{
124	8	if (! $this->cache_handler) {
125	7	$data = $this->download($url);
126	7	return $data;
127		}
128
129	1	$data = $this->attemptGetFromCache($url);
130
131	1	if (!$data) {
132	1	throw new \Exception('Error in download document');
133		}
134
135		return $data;
136		}
137
138		// attemptGetFromCache is called if a cache_handler is available.
139		// It will call the cache handler with a get request, return the
140		// document if found, and will ask it to store the downloaded
141		// object where applicable.
142	1	private function attemptGetFromCache($url)
143		{
144	1	$this->was_cached = false;
145	1	$data = call_user_func($this->cache_handler, 'get', $url);
146
147	1	if ($data) {
148		$this->was_cached = true;
149		return $data;
150		}
151
152	1	$data = $this->download($url);
153
154	1	if ($data) {
155		call_user_func($this->cache_handler, 'set', $url, $data);
156		}
157
158	1	return $data;
159		}
160
161		// arrangeParams converts a parameters array to a query string.
162		// In addition, we add some patches:
163		// 1) trim_start and trim_end are converted from any plain
164		// language syntax to Quandl format
165		// 2) api_key is appended
166	8	private function arrangeParams($params)
167		{
168	8	if ($this->api_key) {
169	8	$params['auth_token'] = $this->api_key;
170	8	}
171
172	8	if (!$params) {
173		return $params;
174		}
175
176	8	foreach (['trim_start', 'trim_end'] as $v) {
177	8	if (isset($params[$v])) {
178	8	$params[$v] = self::convertToQuandlDate($params[$v]);
179	8	}
180	8	}
181
182	8	return http_build_query($params);
183		}
184
185		// convertToQuandlDate converts any time string supported by
186		// PHP (e.g. "today-30 days") to the format needed by Quandl
187	8	private static function convertToQuandlDate($time_str)
188		{
189	8	return date('Y-m-d', strtotime($time_str));
190		}
191
192		/*
193		* download fetches url with file_get_contents or curl fallback
194		* You can force curl download by setting force_curl to true.
195		* You can disable SSL verification for curl by setting
196		* no_ssl_verify to true (solves "SSL certificate problem")
197		*/
198	8	private function download($url)
199		{
200	8	if (! $this->checkUrl($url)) {
201		return false;
202		}
203
204	8	if (ini_get('allow_url_fopen') && !$this->force_curl) {
205	8	return $this->getDataWithFileGetContents($url);
206		}
207
208		if (!function_exists('curl_version')) {
209		$this->error = 'Enable allow_url_fopen or curl';
210		return false;
211		}
212
213		return $this->getDataWithCurl($url);
214		}
215
216		//check url
217	8	private function checkUrl($url)
218		{
219	8	$headers_url = get_headers($url);
220	8	$http_code = $headers_url[0];
221
222	8	if (strpos($http_code, '404') !== false) {
223		$this->error = 'URL not found or invalid URL';
224		return false;
225		}
226
227	8	return true;
228		}
229
230		//download data with file_get_contents PHP function
231	8	private function getDataWithFileGetContents($url)
232		{
233		try {
234	8	return file_get_contents($url);
235	8	} catch (\Exception $e) {
236	8	$this->error = $e->getMessage();
237		}
238	8	}
239
240		//download data with file_get_contents PHP function
241		private function getDataWithCurl($url)
242		{
243		$curl = curl_init();
244
245		curl_setopt($curl, CURLOPT_URL, $url);
246		curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
247
248		// disable ssl verification for curl
249		if ($this->no_ssl_verify) {
250		curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0);
251		}
252
253		$data = curl_exec($curl);
254		$error = curl_error($curl);
255
256		curl_close($curl);
257
258		if (! $error) {
259		return $data;
260		}
261
262		$this->error = $error;
263
264		return false;
265		}
266
267		//construct a array with parameters used to query
268		private function constructParams($query, $page = 1, $per_page = 300)
269		{
270		$params = [
271		"per_page" => $per_page,
272		"page" => $page,
273		"query" => $query,
274		];
275
276		return $params;
277		}
278		}
279

royopa / quandl-elephant-api

Quandl::__construct() A last analyzed 2016-03-12 22:04 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Quandl::__construct() A
last analyzed 2016-03-12 22:04 UTC