1694839170

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/podio-community/podio-php/commit/<a class=hub.com/podio-community/podio-php/commit/c77ee2b046c2de0f735d32f1cbcbcb3b182157a3">c77ee2b04<a href="https://github.com/podio-community/podio-php/commit/c77ee2b046c2de0f735d32f1cbcbcb3b182157a3">">Merge </a><a class="double-link" href="https://github.com/podio-community/podio-php/commit/<a class="double-link" href="https://github.com/podio-community/podio-php/commit/5d8bdfbe01016598c0c71b31ffcf5a3d14f327d5">5d8bdfbe0</a>">5d8bdfbe0</a><a href="https://github.com/podio-community/podio-php/commit/c77ee2b046c2de0f735d32f1cbcbcb3b182157a3"> into 87a1d1868">87a1d1868</a>

Pull Request Pull Request #216: fixing file upload - fixes #215

Run Details

3 of 3 new or added lines in 2 files covered. (100.0%)

944 of 2143 relevant lines covered (44.05%)

8.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lib/Podio.php

<?php

use GuzzleHttp\Client;
use GuzzleHttp\Exception\GuzzleException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Psr7\MultipartStream;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Uri;
use GuzzleHttp\RequestOptions;
use GuzzleHttp\TransferStats;

class Podio
{
    public static $oauth;
    public static $debug;
    public static $logger;
    public static $session_manager;
    public static $last_response;
    public static $auth_type;
    /** @var \GuzzleHttp\Client */
    public static $http_client;
    protected static $url;
    protected static $client_id;
    protected static $client_secret;
    protected static $secret;
    protected static $headers;
    /** @var \Psr\Http\Message\ResponseInterface */
    private static $last_http_response;

    public const VERSION = '6.0.0';

    public const GET = 'GET';
    public const POST = 'POST';
    public const PUT = 'PUT';
    public const DELETE = 'DELETE';

    public static function setup($client_id, $client_secret, $options = array('session_manager' => null, 'curl_options' => array()))
    {
        // Setup client info
        self::$client_id = $client_id;
        self::$client_secret = $client_secret;

        self::$url = empty($options['api_url']) ? 'https://api.podio.com:443' : $options['api_url'];
        self::$debug = self::$debug ? self::$debug : false;
        $client_config = [
      'base_uri' => self::$url,

      RequestOptions::HEADERS => [
        'Accept' => 'application/json',
        'User-Agent' => 'Podio PHP Client/' . self::VERSION . '-guzzle'
      ]
    ];
        if ($options && !empty($options['curl_options'])) {
            $client_config['curl'] = $options['curl_options'];
        }
        if (class_exists('\\Composer\\CaBundle\\CaBundle')) {
            /** @noinspection PhpFullyQualifiedNameUsageInspection */
            $client_config[RequestOptions::VERIFY] = \Composer\CaBundle\CaBundle::getSystemCaRootBundlePath();
        }
        self::$http_client = new Client($client_config);

        self::$session_manager = null;
        if ($options && !empty($options['session_manager'])) {
            if (is_string($options['session_manager']) && class_exists($options['session_manager'])) {
                self::$session_manager = new $options['session_manager']();
            } elseif (is_object($options['session_manager']) && method_exists($options['session_manager'], 'get') && method_exists($options['session_manager'], 'set')) {
                self::$session_manager = $options['session_manager'];
            }
            if (self::$session_manager) {
                self::$oauth = self::$session_manager->get();
            }
        }

        // Register shutdown function for debugging and session management
        register_shutdown_function('Podio::shutdown');
    }

    public static function authenticate_with_app($app_id, $app_token)
    {
        return static::authenticate('app', array('app_id' => $app_id, 'app_token' => $app_token));
    }

    public static function authenticate_with_password($username, $password)
    {
        return static::authenticate('password', array('username' => $username, 'password' => $password));
    }

    public static function authenticate_with_authorization_code($authorization_code, $redirect_uri)
    {
        return static::authenticate('authorization_code', array('code' => $authorization_code, 'redirect_uri' => $redirect_uri));
    }

    public static function refresh_access_token()
    {
        return static::authenticate('refresh_token', array('refresh_token' => self::$oauth->refresh_token));
    }

    public static function authenticate($grant_type, $attributes)
    {
        $data = array();
        $auth_type = array('type' => $grant_type);

        switch ($grant_type) {
      case 'password':
        $data['grant_type'] = 'password';
        $data['username'] = $attributes['username'];
        $data['password'] = $attributes['password'];

        $auth_type['identifier'] = $attributes['username'];
        break;
      case 'refresh_token':
        $data['grant_type'] = 'refresh_token';
        $data['refresh_token'] = $attributes['refresh_token'];
        break;
      case 'authorization_code':
        $data['grant_type'] = 'authorization_code';
        $data['code'] = $attributes['code'];
        $data['redirect_uri'] = $attributes['redirect_uri'];
        break;
      case 'app':
        $data['grant_type'] = 'app';
        $data['app_id'] = $attributes['app_id'];
        $data['app_token'] = $attributes['app_token'];

        $auth_type['identifier'] = $attributes['app_id'];
        break;
      default:
        break;
    }

        $request_data = array_merge($data, array('client_id' => self::$client_id, 'client_secret' => self::$client_secret));
        if ($response = static::request(self::POST, '/oauth/token', $request_data, array('oauth_request' => true))) {
            $body = $response->json_body();
            self::$oauth = new PodioOAuth($body['access_token'], $body['refresh_token'], $body['expires_in'], $body['ref'], $body['scope']);

            // Don't touch auth_type if we are refreshing automatically as it'll be reset to null
            if ($grant_type !== 'refresh_token') {
                self::$auth_type = $auth_type;
            }

            if (self::$session_manager) {
                self::$session_manager->set(self::$oauth, self::$auth_type);
            }

            return true;
        }
        return false;
    }

    public static function clear_authentication()
    {
        self::$oauth = new PodioOAuth();

        if (self::$session_manager) {
            self::$session_manager->set(self::$oauth, self::$auth_type);
        }
    }

    public static function authorize_url($redirect_uri, $scope)
    {
        $parsed_url = parse_url(self::$url);
        $host = str_replace('api.', '', $parsed_url['host']);
        return 'https://' . $host . '/oauth/authorize?response_type=code&client_id=' . self::$client_id . '&redirect_uri=' . rawurlencode($redirect_uri) . '&scope=' . rawurlencode($scope);
    }

    public static function is_authenticated()
    {
        return self::$oauth && self::$oauth->access_token;
    }

    /**
     * @throws PodioBadRequestError
     * @throws PodioConflictError
     * @throws PodioRateLimitError
     * @throws PodioUnavailableError
     * @throws PodioGoneError
     * @throws PodioDataIntegrityError
     * @throws PodioForbiddenError
     * @throws PodioNotFoundError
     * @throws PodioError
     * @throws PodioInvalidGrantError
     * @throws PodioAuthorizationError
     * @throws PodioConnectionError
     * @throws PodioServerError
     * @throws Exception when client is not setup
     */
    public static function request($method, $url, $attributes = array(), $options = array())
    {
        if (!self::$http_client) {
            throw new Exception('Client has not been setup with client id and client secret.');
        }

        $original_url = $url;
        $encoded_attributes = null;

        if (is_object($attributes) && substr(get_class($attributes), 0, 5) == 'Podio') {
            $attributes = $attributes->as_json(false);
        }

        if (!is_array($attributes) && !is_object($attributes)) {
            throw new PodioDataIntegrityError('Attributes must be an array');
        }

        $request = new Request($method, $url);
        switch ($method) {
      case self::DELETE:
      case self::GET:
        $request = $request->withHeader('Content-type', 'application/x-www-form-urlencoded');
        $request = $request->withHeader('Content-length', '0');

        $separator = strpos($url, '?') ? '&' : '?';
        if ($attributes) {
            $query = static::encode_attributes($attributes);
            $request = $request->withUri(new Uri($url . $separator . $query));
        }
        break;
      case self::POST:
        if (!empty($options['upload'])) {
            $request = $request->withBody(new MultipartStream([
            [
              'name' => 'source',
              'contents' => fopen($attributes['filepath'], 'r'),
              'filename' => $attributes['filename']
            ], [
              'name' => 'filename',
              'contents' => $attributes['filename']
            ]
          ]));
        } elseif (empty($options['oauth_request'])) {
            // application/json
            $encoded_attributes = json_encode($attributes);
            $request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));
            $request = $request->withHeader('Content-type', 'application/json');
        } else {
            // x-www-form-urlencoded
            $encoded_attributes = static::encode_attributes($attributes);
            $request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));
            $request = $request->withHeader('Content-type', 'application/x-www-form-urlencoded');
        }
        break;
      case self::PUT:
        $encoded_attributes = json_encode($attributes);
        $request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));
        $request = $request->withHeader('Content-type', 'application/json');
        break;
    }

        // Add access token to request
        if (isset(self::$oauth) && !empty(self::$oauth->access_token) && !(isset($options['oauth_request']) && $options['oauth_request'] == true)) {
            $token = self::$oauth->access_token;
            $request = $request->withHeader('Authorization', "OAuth2 {$token}");
        }

        // File downloads can be of any type
        if (!empty($options['file_download'])) {
            $request = $request->withHeader('Accept', '*/*');
        }

        $response = new PodioResponse();

        try {
            $transferTime = 0;
            /** \Psr\Http\Message\ResponseInterface */
            $http_response = self::$http_client->send($request, [
        RequestOptions::HTTP_ERRORS => false,
        RequestOptions::ON_STATS => function (TransferStats $stats) use (&$transferTime) {
            $transferTime = $stats->getTransferTime();
        }
      ]);
            $response->status = $http_response->getStatusCode();
            $response->headers = array_map(function ($values) {
                return implode(', ', $values);
            }, $http_response->getHeaders());
            self::$last_http_response = $http_response;
            if (!isset($options['return_raw_as_resource_only']) || $options['return_raw_as_resource_only'] != true) {
                $response->body = $http_response->getBody()->getContents();
            }
            self::$last_response = $response;
        } catch (RequestException $requestException) {
            throw new PodioConnectionError('Connection to Podio API failed: [' . get_class($requestException) . '] ' . $requestException->getMessage(), $requestException->getCode());
        } catch (GuzzleException $e) { // this generally should not happen as RequestOptions::HTTP_ERRORS is set to `false`
            throw new PodioConnectionError('Connection to Podio API failed: [' . get_class($e) . '] ' . $e->getMessage(), $e->getCode());
        }

        if (!isset($options['oauth_request'])) {
            static::log_request($method, $url, $encoded_attributes, $response, $transferTime);
        }

        switch ($response->status) {
      case 200:
      case 201:
      case 204:
        if (isset($options['return_raw_as_resource_only']) && $options['return_raw_as_resource_only'] === true) {
            return $http_response->getBody();
        }
        return $response;
      case 400:
        // invalid_grant_error or bad_request_error
        $body = $response->json_body();
        if (strstr($body['error'], 'invalid_grant')) {
            // Reset access token & refresh_token
            static::clear_authentication();
            throw new PodioInvalidGrantError($response->body, $response->status, $url);
        } else {
            throw new PodioBadRequestError($response->body, $response->status, $url);
        }
        // no break
      case 401:
        $body = $response->json_body();
        if (strstr($body['error_description'], 'expired_token') || strstr($body['error'], 'invalid_token')) {
            if (self::$oauth->refresh_token) {
                // Access token is expired. Try to refresh it.
                if (static::refresh_access_token()) {
                    // Try the original request again.
                    return static::request($method, $original_url, $attributes);
                } else {
                    static::clear_authentication();
                    throw new PodioAuthorizationError($response->body, $response->status, $url);
                }
            } else {
                // We have tried in vain to get a new access token. Log the user out.
                static::clear_authentication();
                throw new PodioAuthorizationError($response->body, $response->status, $url);
            }
        } elseif (strstr($body['error'], 'invalid_request') || strstr($body['error'], 'unauthorized')) {
            // Access token is invalid.
            static::clear_authentication();
            throw new PodioAuthorizationError($response->body, $response->status, $url);
        }
        break;
      case 403:
        throw new PodioForbiddenError($response->body, $response->status, $url);
      case 404:
        throw new PodioNotFoundError($response->body, $response->status, $url);
      case 409:
        throw new PodioConflictError($response->body, $response->status, $url);
      case 410:
        throw new PodioGoneError($response->body, $response->status, $url);
      case 420:
        throw new PodioRateLimitError($response->body, $response->status, $url);
      case 500:
        throw new PodioServerError($response->body, $response->status, $url);
      case 502:
      case 503:
      case 504:
        throw new PodioUnavailableError($response->body, $response->status, $url);
      default:
        throw new PodioError($response->body, $response->status, $url);
    }
        return false;
    }

    public static function get($url, $attributes = array(), $options = array())
    {
        return static::request(Podio::GET, $url, $attributes, $options);
    }
    public static function post($url, $attributes = array(), $options = array())
    {
        return static::request(Podio::POST, $url, $attributes, $options);
    }
    public static function put($url, $attributes = array())
    {
        return static::request(Podio::PUT, $url, $attributes);
    }
    public static function delete($url, $attributes = array())
    {
        return static::request(Podio::DELETE, $url, $attributes);
    }

    public static function encode_attributes($attributes)
    {
        $return = array();
        foreach ($attributes as $key => $value) {
            $return[] = urlencode($key) . '=' . urlencode($value);
        }
        return join('&', $return);
    }
    public static function url_with_options($url, $options)
    {
        $parameters = array();

        if (isset($options['silent']) && $options['silent']) {
            $parameters[] = 'silent=1';
        }

        if (isset($options['hook']) && !$options['hook']) {
            $parameters[] = 'hook=false';
        }

        if (!empty($options['fields'])) {
            $parameters[] = 'fields=' . $options['fields'];
        }

        return $parameters ? $url . '?' . join('&', $parameters) : $url;
    }

    public static function rate_limit_remaining()
    {
        if (isset(self::$last_http_response)) {
            return implode(self::$last_http_response->getHeader('x-rate-limit-remaining'));
        }
        return '-1';
    }

    public static function rate_limit()
    {
        if (isset(self::$last_http_response)) {
            return implode(self::$last_http_response->getHeader('x-rate-limit-limit'));
        }
        return '-1';
    }

    /**
     * Set debug config
     *
     * @param $toggle boolean True to enable debugging. False to disable
     * @param $output string Output mode. Can be "stdout" or "file". Default is "stdout"
     */
    public static function set_debug($toggle, $output = "stdout")
    {
        if ($toggle) {
            self::$debug = $output;
        } else {
            self::$debug = false;
        }
    }

    public static function log_request($method, $url, $encoded_attributes, $response, $transferTime)
    {
        if (self::$debug) {
            $timestamp = gmdate('Y-m-d H:i:s');
            $text = "{$timestamp} {$response->status} {$method} {$url}\n";
            if (!empty($encoded_attributes)) {
                $text .= "{$timestamp} Request body: " . $encoded_attributes . "\n";
            }
            $text .= "{$timestamp} Reponse: {$response->body}\n\n";

            if (self::$debug === 'file') {
                if (!self::$logger) {
                    self::$logger = new PodioLogger();
                }
                self::$logger->log($text);
            } elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {
                print $text;
            } elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {
                require_once 'vendor/kint/Kint.class.php';
                Kint::dump("{$method} {$url}", $encoded_attributes, $response);
            }

            self::$logger->call_log[] = $transferTime;
        }
    }

    public static function shutdown()
    {
        // Write any new access and refresh tokens to session.
        if (self::$session_manager) {
            self::$session_manager->set(self::$oauth, self::$auth_type);
        }

        // Log api call times if debugging
        if (self::$debug && self::$logger) {
            $timestamp = gmdate('Y-m-d H:i:s');
            $count = sizeof(self::$logger->call_log);
            $duration = 0;
            if (self::$logger->call_log) {
                foreach (self::$logger->call_log as $val) {
                    $duration += $val;
                }
            }

            $text = "\n{$timestamp} Performed {$count} request(s) in {$duration} seconds\n";
            if (self::$debug === 'file') {
                if (!self::$logger) {
                    self::$logger = new PodioLogger();
                }
                self::$logger->log($text);
            } elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {
                print $text;
            }
        }
    }
}

1	<?php
2
3	use GuzzleHttp\Client;
4	use GuzzleHttp\Exception\GuzzleException;
5	use GuzzleHttp\Exception\RequestException;
6	use GuzzleHttp\Psr7\MultipartStream;
7	use GuzzleHttp\Psr7\Request;
8	use GuzzleHttp\Psr7\Uri;
9	use GuzzleHttp\RequestOptions;
10	use GuzzleHttp\TransferStats;
11
12	class Podio
13	{
14	public static $oauth;
15	public static $debug;
16	public static $logger;
17	public static $session_manager;
18	public static $last_response;
19	public static $auth_type;
20	/** @var \GuzzleHttp\Client */
21	public static $http_client;
22	protected static $url;
23	protected static $client_id;
24	protected static $client_secret;
25	protected static $secret;
26	protected static $headers;
27	/** @var \Psr\Http\Message\ResponseInterface */
28	private static $last_http_response;
29
30	public const VERSION = '6.0.0';
31
32	public const GET = 'GET';
33	public const POST = 'POST';
34	public const PUT = 'PUT';
35	public const DELETE = 'DELETE';
36
37	public static function setup($client_id, $client_secret, $options = array('session_manager' => null, 'curl_options' => array()))
38	{
39	// Setup client info
40	self::$client_id = $client_id;	×
41	self::$client_secret = $client_secret;	×
42
43	self::$url = empty($options['api_url']) ? 'https://api.podio.com:443' : $options['api_url'];	×
44	self::$debug = self::$debug ? self::$debug : false;	×
45	$client_config = [
46	'base_uri' => self::$url,	×
47
48	RequestOptions::HEADERS => [	×
49	'Accept' => 'application/json',
50	'User-Agent' => 'Podio PHP Client/' . self::VERSION . '-guzzle'
51	]
52	];
53	if ($options && !empty($options['curl_options'])) {	×
54	$client_config['curl'] = $options['curl_options'];	×
55	}
56	if (class_exists('\\Composer\\CaBundle\\CaBundle')) {	×
57	/** @noinspection PhpFullyQualifiedNameUsageInspection */
58	$client_config[RequestOptions::VERIFY] = \Composer\CaBundle\CaBundle::getSystemCaRootBundlePath();	×
59	}
60	self::$http_client = new Client($client_config);	×
61
62	self::$session_manager = null;	×
63	if ($options && !empty($options['session_manager'])) {	×
64	if (is_string($options['session_manager']) && class_exists($options['session_manager'])) {	×
65	self::$session_manager = new $options['session_manager']();	×
66	} elseif (is_object($options['session_manager']) && method_exists($options['session_manager'], 'get') && method_exists($options['session_manager'], 'set')) {	×
67	self::$session_manager = $options['session_manager'];	×
68	}
69	if (self::$session_manager) {	×
70	self::$oauth = self::$session_manager->get();	×
71	}
72	}
73
74	// Register shutdown function for debugging and session management
75	register_shutdown_function('Podio::shutdown');	×
76	}	×
77
78	public static function authenticate_with_app($app_id, $app_token)
79	{
80	return static::authenticate('app', array('app_id' => $app_id, 'app_token' => $app_token));	×
81	}
82
83	public static function authenticate_with_password($username, $password)
84	{
85	return static::authenticate('password', array('username' => $username, 'password' => $password));	×
86	}
87
88	public static function authenticate_with_authorization_code($authorization_code, $redirect_uri)
89	{
90	return static::authenticate('authorization_code', array('code' => $authorization_code, 'redirect_uri' => $redirect_uri));	×
91	}
92
93	public static function refresh_access_token()
94	{
95	return static::authenticate('refresh_token', array('refresh_token' => self::$oauth->refresh_token));	×
96	}
97
98	public static function authenticate($grant_type, $attributes)
99	{
100	$data = array();	×
101	$auth_type = array('type' => $grant_type);	×
102
103	switch ($grant_type) {	×
104	case 'password':	×
105	$data['grant_type'] = 'password';	×
106	$data['username'] = $attributes['username'];	×
107	$data['password'] = $attributes['password'];	×
108
109	$auth_type['identifier'] = $attributes['username'];	×
110	break;	×
111	case 'refresh_token':	×
112	$data['grant_type'] = 'refresh_token';	×
113	$data['refresh_token'] = $attributes['refresh_token'];	×
114	break;	×
115	case 'authorization_code':	×
116	$data['grant_type'] = 'authorization_code';	×
117	$data['code'] = $attributes['code'];	×
118	$data['redirect_uri'] = $attributes['redirect_uri'];	×
119	break;	×
120	case 'app':	×
121	$data['grant_type'] = 'app';	×
122	$data['app_id'] = $attributes['app_id'];	×
123	$data['app_token'] = $attributes['app_token'];	×
124
125	$auth_type['identifier'] = $attributes['app_id'];	×
126	break;	×
127	default:
128	break;	×
129	}
130
131	$request_data = array_merge($data, array('client_id' => self::$client_id, 'client_secret' => self::$client_secret));	×
132	if ($response = static::request(self::POST, '/oauth/token', $request_data, array('oauth_request' => true))) {	×
133	$body = $response->json_body();	×
134	self::$oauth = new PodioOAuth($body['access_token'], $body['refresh_token'], $body['expires_in'], $body['ref'], $body['scope']);	×
135
136	// Don't touch auth_type if we are refreshing automatically as it'll be reset to null
137	if ($grant_type !== 'refresh_token') {	×
138	self::$auth_type = $auth_type;	×
139	}
140
141	if (self::$session_manager) {	×
142	self::$session_manager->set(self::$oauth, self::$auth_type);	×
143	}
144
145	return true;	×
146	}
147	return false;	×
148	}
149
150	public static function clear_authentication()
151	{
152	self::$oauth = new PodioOAuth();	×
153
154	if (self::$session_manager) {	×
155	self::$session_manager->set(self::$oauth, self::$auth_type);	×
156	}
157	}	×
158
159	public static function authorize_url($redirect_uri, $scope)
160	{
161	$parsed_url = parse_url(self::$url);	×
162	$host = str_replace('api.', '', $parsed_url['host']);	×
163	return 'https://' . $host . '/oauth/authorize?response_type=code&client_id=' . self::$client_id . '&redirect_uri=' . rawurlencode($redirect_uri) . '&scope=' . rawurlencode($scope);	×
164	}
165
166	public static function is_authenticated()
167	{
168	return self::$oauth && self::$oauth->access_token;	×
169	}
170
171	/**
172	* @throws PodioBadRequestError
173	* @throws PodioConflictError
174	* @throws PodioRateLimitError
175	* @throws PodioUnavailableError
176	* @throws PodioGoneError
177	* @throws PodioDataIntegrityError
178	* @throws PodioForbiddenError
179	* @throws PodioNotFoundError
180	* @throws PodioError
181	* @throws PodioInvalidGrantError
182	* @throws PodioAuthorizationError
183	* @throws PodioConnectionError
184	* @throws PodioServerError
185	* @throws Exception when client is not setup
186	*/
187	public static function request($method, $url, $attributes = array(), $options = array())
188	{
189	if (!self::$http_client) {	×
190	throw new Exception('Client has not been setup with client id and client secret.');	×
191	}
192
193	$original_url = $url;	×
194	$encoded_attributes = null;	×
195
196	if (is_object($attributes) && substr(get_class($attributes), 0, 5) == 'Podio') {	×
197	$attributes = $attributes->as_json(false);	×
198	}
199
200	if (!is_array($attributes) && !is_object($attributes)) {	×
201	throw new PodioDataIntegrityError('Attributes must be an array');	×
202	}
203
204	$request = new Request($method, $url);	×
205	switch ($method) {	×
206	case self::DELETE:
207	case self::GET:
208	$request = $request->withHeader('Content-type', 'application/x-www-form-urlencoded');	×
209	$request = $request->withHeader('Content-length', '0');	×
210
211	$separator = strpos($url, '?') ? '&' : '?';	×
212	if ($attributes) {	×
213	$query = static::encode_attributes($attributes);	×
214	$request = $request->withUri(new Uri($url . $separator . $query));	×
215	}
216	break;	×
217	case self::POST:
218	if (!empty($options['upload'])) {	×
219	$request = $request->withBody(new MultipartStream([	×
220	[
221	'name' => 'source',	×
222	'contents' => fopen($attributes['filepath'], 'r'),	×
223	'filename' => $attributes['filename']	×
224	], [
225	'name' => 'filename',	×
226	'contents' => $attributes['filename']	×
227	]
228	]));
229	} elseif (empty($options['oauth_request'])) {	×
230	// application/json
231	$encoded_attributes = json_encode($attributes);	×
232	$request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));	×
233	$request = $request->withHeader('Content-type', 'application/json');	×
234	} else {
235	// x-www-form-urlencoded
236	$encoded_attributes = static::encode_attributes($attributes);	×
237	$request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));	×
238	$request = $request->withHeader('Content-type', 'application/x-www-form-urlencoded');	×
239	}
240	break;	×
241	case self::PUT:
242	$encoded_attributes = json_encode($attributes);	×
243	$request = $request->withBody(GuzzleHttp\Psr7\Utils::streamFor($encoded_attributes));	×
244	$request = $request->withHeader('Content-type', 'application/json');	×
245	break;	×
246	}
247
248	// Add access token to request
249	if (isset(self::$oauth) && !empty(self::$oauth->access_token) && !(isset($options['oauth_request']) && $options['oauth_request'] == true)) {	×
250	$token = self::$oauth->access_token;	×
251	$request = $request->withHeader('Authorization', "OAuth2 {$token}");	×
252	}
253
254	// File downloads can be of any type
255	if (!empty($options['file_download'])) {	×
256	$request = $request->withHeader('Accept', '/');	×
257	}
258
259	$response = new PodioResponse();	×
260
261	try {
262	$transferTime = 0;	×
263	/** \Psr\Http\Message\ResponseInterface */
264	$http_response = self::$http_client->send($request, [	×
265	RequestOptions::HTTP_ERRORS => false,	×
266	RequestOptions::ON_STATS => function (TransferStats $stats) use (&$transferTime) {	×
267	$transferTime = $stats->getTransferTime();	×
268	}	×
269	]);
270	$response->status = $http_response->getStatusCode();	×
271	$response->headers = array_map(function ($values) {	×
272	return implode(', ', $values);	×
273	}, $http_response->getHeaders());	×
274	self::$last_http_response = $http_response;	×
275	if (!isset($options['return_raw_as_resource_only']) \|\| $options['return_raw_as_resource_only'] != true) {	×
276	$response->body = $http_response->getBody()->getContents();	×
277	}
278	self::$last_response = $response;	×
279	} catch (RequestException $requestException) {	×
280	throw new PodioConnectionError('Connection to Podio API failed: [' . get_class($requestException) . '] ' . $requestException->getMessage(), $requestException->getCode());	×
281	} catch (GuzzleException $e) { // this generally should not happen as RequestOptions::HTTP_ERRORS is set to `false`	×
282	throw new PodioConnectionError('Connection to Podio API failed: [' . get_class($e) . '] ' . $e->getMessage(), $e->getCode());	×
283	}
284
285	if (!isset($options['oauth_request'])) {	×
286	static::log_request($method, $url, $encoded_attributes, $response, $transferTime);	×
287	}
288
289	switch ($response->status) {	×
290	case 200:	×
291	case 201:	×
292	case 204:	×
293	if (isset($options['return_raw_as_resource_only']) && $options['return_raw_as_resource_only'] === true) {	×
294	return $http_response->getBody();	×
295	}
296	return $response;	×
297	case 400:	×
298	// invalid_grant_error or bad_request_error
299	$body = $response->json_body();	×
300	if (strstr($body['error'], 'invalid_grant')) {	×
301	// Reset access token & refresh_token
302	static::clear_authentication();	×
303	throw new PodioInvalidGrantError($response->body, $response->status, $url);	×
304	} else {
305	throw new PodioBadRequestError($response->body, $response->status, $url);	×
306	}
307	// no break
308	case 401:	×
309	$body = $response->json_body();	×
310	if (strstr($body['error_description'], 'expired_token') \|\| strstr($body['error'], 'invalid_token')) {	×
311	if (self::$oauth->refresh_token) {	×
312	// Access token is expired. Try to refresh it.
313	if (static::refresh_access_token()) {	×
314	// Try the original request again.
315	return static::request($method, $original_url, $attributes);	×
316	} else {
317	static::clear_authentication();	×
318	throw new PodioAuthorizationError($response->body, $response->status, $url);	×
319	}
320	} else {
321	// We have tried in vain to get a new access token. Log the user out.
322	static::clear_authentication();	×
323	throw new PodioAuthorizationError($response->body, $response->status, $url);	×
324	}
325	} elseif (strstr($body['error'], 'invalid_request') \|\| strstr($body['error'], 'unauthorized')) {	×
326	// Access token is invalid.
327	static::clear_authentication();	×
328	throw new PodioAuthorizationError($response->body, $response->status, $url);	×
329	}
330	break;	×
331	case 403:	×
332	throw new PodioForbiddenError($response->body, $response->status, $url);	×
333	case 404:	×
334	throw new PodioNotFoundError($response->body, $response->status, $url);	×
335	case 409:	×
336	throw new PodioConflictError($response->body, $response->status, $url);	×
337	case 410:	×
338	throw new PodioGoneError($response->body, $response->status, $url);	×
339	case 420:	×
340	throw new PodioRateLimitError($response->body, $response->status, $url);	×
341	case 500:	×
342	throw new PodioServerError($response->body, $response->status, $url);	×
343	case 502:	×
344	case 503:	×
345	case 504:	×
346	throw new PodioUnavailableError($response->body, $response->status, $url);	×
347	default:
348	throw new PodioError($response->body, $response->status, $url);	×
349	}
350	return false;	×
351	}
352
353	public static function get($url, $attributes = array(), $options = array())
354	{
355	return static::request(Podio::GET, $url, $attributes, $options);	×
356	}
357	public static function post($url, $attributes = array(), $options = array())
358	{
359	return static::request(Podio::POST, $url, $attributes, $options);	×
360	}
361	public static function put($url, $attributes = array())
362	{
363	return static::request(Podio::PUT, $url, $attributes);	×
364	}
365	public static function delete($url, $attributes = array())
366	{
367	return static::request(Podio::DELETE, $url, $attributes);	×
368	}
369
370	public static function encode_attributes($attributes)
371	{
372	$return = array();	×
373	foreach ($attributes as $key => $value) {	×
374	$return[] = urlencode($key) . '=' . urlencode($value);	×
375	}
376	return join('&', $return);	×
377	}
378	public static function url_with_options($url, $options)
379	{
380	$parameters = array();	×
381
382	if (isset($options['silent']) && $options['silent']) {	×
383	$parameters[] = 'silent=1';	×
384	}
385
386	if (isset($options['hook']) && !$options['hook']) {	×
387	$parameters[] = 'hook=false';	×
388	}
389
390	if (!empty($options['fields'])) {	×
391	$parameters[] = 'fields=' . $options['fields'];	×
392	}
393
394	return $parameters ? $url . '?' . join('&', $parameters) : $url;	×
395	}
396
397	public static function rate_limit_remaining()
398	{
399	if (isset(self::$last_http_response)) {	×
400	return implode(self::$last_http_response->getHeader('x-rate-limit-remaining'));	×
401	}
402	return '-1';	×
403	}
404
405	public static function rate_limit()
406	{
407	if (isset(self::$last_http_response)) {	×
408	return implode(self::$last_http_response->getHeader('x-rate-limit-limit'));	×
409	}
410	return '-1';	×
411	}
412
413	/**
414	* Set debug config
415	*
416	* @param $toggle boolean True to enable debugging. False to disable
417	* @param $output string Output mode. Can be "stdout" or "file". Default is "stdout"
418	*/
419	public static function set_debug($toggle, $output = "stdout")
420	{
421	if ($toggle) {	×
422	self::$debug = $output;	×
423	} else {
424	self::$debug = false;	×
425	}
426	}	×
427
428	public static function log_request($method, $url, $encoded_attributes, $response, $transferTime)
429	{
430	if (self::$debug) {	×
431	$timestamp = gmdate('Y-m-d H:i:s');	×
432	$text = "{$timestamp} {$response->status} {$method} {$url}\n";	×
433	if (!empty($encoded_attributes)) {	×
434	$text .= "{$timestamp} Request body: " . $encoded_attributes . "\n";	×
435	}
436	$text .= "{$timestamp} Reponse: {$response->body}\n\n";	×
437
438	if (self::$debug === 'file') {	×
439	if (!self::$logger) {	×
440	self::$logger = new PodioLogger();	×
441	}
442	self::$logger->log($text);	×
443	} elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {	×
444	print $text;	×
445	} elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {	×
446	require_once 'vendor/kint/Kint.class.php';	×
447	Kint::dump("{$method} {$url}", $encoded_attributes, $response);	×
448	}
449
450	self::$logger->call_log[] = $transferTime;	×
451	}
452	}	×
453
454	public static function shutdown()
455	{
456	// Write any new access and refresh tokens to session.
457	if (self::$session_manager) {	×
458	self::$session_manager->set(self::$oauth, self::$auth_type);	×
459	}
460
461	// Log api call times if debugging
462	if (self::$debug && self::$logger) {	×
463	$timestamp = gmdate('Y-m-d H:i:s');	×
464	$count = sizeof(self::$logger->call_log);	×
465	$duration = 0;	×
466	if (self::$logger->call_log) {	×
467	foreach (self::$logger->call_log as $val) {	×
468	$duration += $val;	×
469	}
470	}
471
472	$text = "\n{$timestamp} Performed {$count} request(s) in {$duration} seconds\n";	×
473	if (self::$debug === 'file') {	×
474	if (!self::$logger) {	×
475	self::$logger = new PodioLogger();	×
476	}
477	self::$logger->log($text);	×
478	} elseif (self::$debug === 'stdout' && php_sapi_name() === 'cli') {	×
479	print $text;	×
480	}
481	}
482	}	×
483	}

podio-community / podio-php / 1694839170

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous