AS1024/Kanboard-Prod
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch to composer

Browse Source
This commit is contained in:
Frédéric Guillot
2014-11-04 21:33:05 -05:00
parent 850645dd6b
commit 135b921db7
288 changed files with 26 additions and 33663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
vendor/.htaccess vendored
View File

@@ -1 +0,0 @@
Deny from all

182
vendor/JsonRPC/Client.php vendored
View File

@@ -1,182 +0,0 @@
<?php
namespace JsonRPC;
use BadFunctionCallException;
/**
* JsonRPC client class
*
* @package JsonRPC
* @author Frederic Guillot
* @license Unlicense http://unlicense.org/
*/
class Client
{
/**
* URL of the server
*
* @access private
* @var string
*/
private $url;
/**
* HTTP client timeout
*
* @access private
* @var integer
*/
private $timeout;
/**
* Username for authentication
*
* @access private
* @var string
*/
private $username;
/**
* Password for authentication
*
* @access private
* @var string
*/
private $password;
/**
* Enable debug output to the php error log
*
* @access public
* @var boolean
*/
public $debug = false;
/**
* Default HTTP headers to send to the server
*
* @access private
* @var array
*/
private $headers = array(
'Connection: close',
'Content-Type: application/json',
'Accept: application/json'
);
/**
* Constructor
*
* @access public
* @param string $url Server URL
* @param integer $timeout Server URL
* @param array $headers Custom HTTP headers
*/
public function __construct($url, $timeout = 5, $headers = array())
{
$this->url = $url;
$this->timeout = $timeout;
$this->headers = array_merge($this->headers, $headers);
}
/**
* Automatic mapping of procedures
*
* @access public
* @param string $method Procedure name
* @param array $params Procedure arguments
* @return mixed
*/
public function __call($method, array $params)
{
// Allow to pass an array and use named arguments
if (count($params) === 1 && is_array($params[0])) {
$params = $params[0];
}
return $this->execute($method, $params);
}
/**
* Set authentication parameters
*
* @access public
* @param string $username Username
* @param string $password Password
*/
public function authentication($username, $password)
{
$this->username = $username;
$this->password = $password;
}
/**
* Execute
*
* @access public
* @throws BadFunctionCallException Exception thrown when a bad request is made (missing argument/procedure)
* @param string $procedure Procedure name
* @param array $params Procedure arguments
* @return mixed
*/
public function execute($procedure, array $params = array())
{
$id = mt_rand();
$payload = array(
'jsonrpc' => '2.0',
'method' => $procedure,
'id' => $id
);
if (! empty($params)) {
$payload['params'] = $params;
}
$result = $this->doRequest($payload);
if (isset($result['id']) && $result['id'] == $id && array_key_exists('result', $result)) {
return $result['result'];
}
throw new BadFunctionCallException('Bad Request');
}
/**
* Do the HTTP request
*
* @access public
* @param string $payload Data to send
*/
public function doRequest($payload)
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_USERAGENT, 'JSON-RPC PHP Client');
curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
if ($this->username && $this->password) {
curl_setopt($ch, CURLOPT_USERPWD, $this->username.':'.$this->password);
}
$result = curl_exec($ch);
$response = json_decode($result, true);
if ($this->debug) {
error_log('==> Request: '.PHP_EOL.json_encode($payload, JSON_PRETTY_PRINT));
error_log('==> Response: '.PHP_EOL.json_encode($response, JSON_PRETTY_PRINT));
}
curl_close($ch);
return is_array($response) ? $response : array();
}
}

352
vendor/JsonRPC/Server.php vendored
View File

@@ -1,352 +0,0 @@
<?php
namespace JsonRPC;
use ReflectionFunction;
use Closure;
/**
* JsonRPC server class
*
* @package JsonRPC
* @author Frederic Guillot
* @license Unlicense http://unlicense.org/
*/
class Server
{
/**
* Data received from the client
*
* @access private
* @var string
*/
private $payload;
/**
* List of procedures
*
* @static
* @access private
* @var array
*/
static private $procedures = array();
/**
* Constructor
*
* @access public
* @param string $payload Client data
*/
public function __construct($payload = '')
{
$this->payload = $payload;
}
/**
* IP based client restrictions
*
* Return an HTTP error 403 if the client is not allowed
*
* @access public
* @param array $hosts List of hosts
*/
public function allowHosts(array $hosts) {
if (! in_array($_SERVER['REMOTE_ADDR'], $hosts)) {
header('Content-Type: application/json');
header('HTTP/1.0 403 Forbidden');
echo '["Access Forbidden"]';
exit;
}
}
/**
* HTTP Basic authentication
*
* Return an HTTP error 401 if the client is not allowed
*
* @access public
* @param array $users Map of username/password
*/
public function authentication(array $users)
{
// OVH workaround
if (isset($_SERVER['REMOTE_USER'])) {
list($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']) = explode(':', base64_decode(substr($_SERVER['REMOTE_USER'], 6)));
}
if (! isset($_SERVER['PHP_AUTH_USER']) ||
! isset($users[$_SERVER['PHP_AUTH_USER']]) ||
$users[$_SERVER['PHP_AUTH_USER']] !== $_SERVER['PHP_AUTH_PW']) {
header('WWW-Authenticate: Basic realm="JsonRPC"');
header('Content-Type: application/json');
header('HTTP/1.0 401 Unauthorized');
echo '["Authentication failed"]';
exit;
}
}
/**
* Register a new procedure
*
* @access public
* @param string $name Procedure name
* @param closure $callback Callback
*/
public function register($name, Closure $callback)
{
self::$procedures[$name] = $callback;
}
/**
* Unregister a procedure
*
* @access public
* @param string $name Procedure name
*/
public function unregister($name)
{
if (isset(self::$procedures[$name])) {
unset(self::$procedures[$name]);
}
}
/**
* Unregister all procedures
*
* @access public
*/
public function unregisterAll()
{
self::$procedures = array();
}
/**
* Return the response to the client
*
* @access public
* @param array $data Data to send to the client
* @param array $payload Incoming data
* @return string
*/
public function getResponse(array $data, array $payload = array())
{
if (! array_key_exists('id', $payload)) {
return '';
}
$response = array(
'jsonrpc' => '2.0',
'id' => $payload['id']
);
$response = array_merge($response, $data);
@header('Content-Type: application/json');
return json_encode($response);
}
/**
* Map arguments to the procedure
*
* @access public
* @param array $request_params Incoming arguments
* @param array $method_params Procedure arguments
* @param array $params Arguments to pass to the callback
* @param integer $nb_required_params Number of required parameters
* @return bool
*/
public function mapParameters(array $request_params, array $method_params, array &$params, $nb_required_params)
{
if (count($request_params) < $nb_required_params) {
return false;
}
// Positional parameters
if (array_keys($request_params) === range(0, count($request_params) - 1)) {
$params = $request_params;
return true;
}
// Named parameters
foreach ($method_params as $p) {
$name = $p->getName();
if (isset($request_params[$name])) {
$params[$name] = $request_params[$name];
}
else if ($p->isDefaultValueAvailable()) {
$params[$name] = $p->getDefaultValue();
}
else {
return false;
}
}
return true;
}
/**
* Parse the payload and test if the parsed JSON is ok
*
* @access public
* @return boolean
*/
public function isValidJsonFormat()
{
if (empty($this->payload)) {
$this->payload = file_get_contents('php://input');
}
if (is_string($this->payload)) {
$this->payload = json_decode($this->payload, true);
}
return is_array($this->payload);
}
/**
* Test if all required JSON-RPC parameters are here
*
* @access public
* @return boolean
*/
public function isValidJsonRpcFormat()
{
if (! isset($this->payload['jsonrpc']) ||
! isset($this->payload['method']) ||
! is_string($this->payload['method']) ||
$this->payload['jsonrpc'] !== '2.0' ||
(isset($this->payload['params']) && ! is_array($this->payload['params']))) {
return false;
}
return true;
}
/**
* Return true if we have a batch request
*
* @access public
* @return boolean
*/
private function isBatchRequest()
{
return array_keys($this->payload) === range(0, count($this->payload) - 1);
}
/**
* Handle batch request
*
* @access private
* @return string
*/
private function handleBatchRequest()
{
$responses = array();
foreach ($this->payload as $payload) {
if (! is_array($payload)) {
$responses[] = $this->getResponse(array(
'error' => array(
'code' => -32600,
'message' => 'Invalid Request'
)),
array('id' => null)
);
}
else {
$server = new Server($payload);
$response = $server->execute();
if ($response) {
$responses[] = $response;
}
}
}
return empty($responses) ? '' : '['.implode(',', $responses).']';
}
/**
* Parse incoming requests
*
* @access public
* @return string
*/
public function execute()
{
// Invalid Json
if (! $this->isValidJsonFormat()) {
return $this->getResponse(array(
'error' => array(
'code' => -32700,
'message' => 'Parse error'
)),
array('id' => null)
);
}
// Handle batch request
if ($this->isBatchRequest()){
return $this->handleBatchRequest();
}
// Invalid JSON-RPC format
if (! $this->isValidJsonRpcFormat()) {
return $this->getResponse(array(
'error' => array(
'code' => -32600,
'message' => 'Invalid Request'
)),
array('id' => null)
);
}
// Procedure not found
if (! isset(self::$procedures[$this->payload['method']])) {
return $this->getResponse(array(
'error' => array(
'code' => -32601,
'message' => 'Method not found'
)),
$this->payload
);
}
// Execute the procedure
$callback = self::$procedures[$this->payload['method']];
$params = array();
$reflection = new ReflectionFunction($callback);
if (isset($this->payload['params'])) {
$parameters = $reflection->getParameters();
if (! $this->mapParameters($this->payload['params'], $parameters, $params, $reflection->getNumberOfRequiredParameters())) {
return $this->getResponse(array(
'error' => array(
'code' => -32602,
'message' => 'Invalid params'
)),
$this->payload
);
}
}
$result = $reflection->invokeArgs($params);
return $this->getResponse(array('result' => $result), $this->payload);
}
}

81
vendor/OAuth/Common/AutoLoader.php vendored
View File

@@ -1,81 +0,0 @@
<?php
namespace OAuth\Common;
/**
* PSR-0 Autoloader
*
* @author ieter Hordijk <info@pieterhordijk.com>
*/
class AutoLoader
{
/**
* @var string The namespace prefix for this instance.
*/
protected $namespace = '';
/**
* @var string The filesystem prefix to use for this instance
*/
protected $path = '';
/**
* Build the instance of the autoloader
*
* @param string $namespace The prefixed namespace this instance will load
* @param string $path The filesystem path to the root of the namespace
*/
public function __construct($namespace, $path)
{
$this->namespace = ltrim($namespace, '\\');
$this->path = rtrim($path, '/\\') . DIRECTORY_SEPARATOR;
}
/**
* Try to load a class
*
* @param string $class The class name to load
*
* @return boolean If the loading was successful
*/
public function load($class)
{
$class = ltrim($class, '\\');
if (strpos($class, $this->namespace) === 0) {
$nsparts = explode('\\', $class);
$class = array_pop($nsparts);
$nsparts[] = '';
$path = $this->path . implode(DIRECTORY_SEPARATOR, $nsparts);
$path .= str_replace('_', DIRECTORY_SEPARATOR, $class) . '.php';
if (file_exists($path)) {
require $path;
return true;
}
}
return false;
}
/**
* Register the autoloader to PHP
*
* @return boolean The status of the registration
*/
public function register()
{
return spl_autoload_register(array($this, 'load'));
}
/**
* Unregister the autoloader to PHP
*
* @return boolean The status of the unregistration
*/
public function unregister()
{
return spl_autoload_unregister(array($this, 'load'));
}
}

60
vendor/OAuth/Common/Consumer/Credentials.php vendored
View File

@@ -1,60 +0,0 @@
<?php
namespace OAuth\Common\Consumer;
/**
* Value object for the credentials of an OAuth service.
*/
class Credentials implements CredentialsInterface
{
/**
* @var string
*/
protected $consumerId;
/**
* @var string
*/
protected $consumerSecret;
/**
* @var string
*/
protected $callbackUrl;
/**
* @param string $consumerId
* @param string $consumerSecret
* @param string $callbackUrl
*/
public function __construct($consumerId, $consumerSecret, $callbackUrl)
{
$this->consumerId = $consumerId;
$this->consumerSecret = $consumerSecret;
$this->callbackUrl = $callbackUrl;
}
/**
* @return string
*/
public function getCallbackUrl()
{
return $this->callbackUrl;
}
/**
* @return string
*/
public function getConsumerId()
{
return $this->consumerId;
}
/**
* @return string
*/
public function getConsumerSecret()
{
return $this->consumerSecret;
}
}

24
vendor/OAuth/Common/Consumer/CredentialsInterface.php vendored
View File

@@ -1,24 +0,0 @@
<?php
namespace OAuth\Common\Consumer;
/**
* Credentials Interface, credentials should implement this.
*/
interface CredentialsInterface
{
/**
* @return string
*/
public function getCallbackUrl();
/**
* @return string
*/
public function getConsumerId();
/**
* @return string
*/
public function getConsumerSecret();
}

10
vendor/OAuth/Common/Exception/Exception.php vendored
View File

@@ -1,10 +0,0 @@
<?php
namespace OAuth\Common\Exception;
/**
* Generic library-level exception.
*/
class Exception extends \Exception
{
}

73
vendor/OAuth/Common/Http/Client/AbstractClient.php vendored
View File

@@ -1,73 +0,0 @@
<?php
namespace OAuth\Common\Http\Client;
/**
* Abstract HTTP client
*/
abstract class AbstractClient implements ClientInterface
{
/**
* @var string The user agent string passed to services
*/
protected $userAgent;
/**
* @var int The maximum number of redirects
*/
protected $maxRedirects = 5;
/**
* @var int The maximum timeout
*/
protected $timeout = 15;
/**
* Creates instance
*
* @param string $userAgent The UA string the client will use
*/
public function __construct($userAgent = 'PHPoAuthLib')
{
$this->userAgent = $userAgent;
}
/**
* @param int $redirects Maximum redirects for client
*
* @return ClientInterface
*/
public function setMaxRedirects($redirects)
{
$this->maxRedirects = $redirects;
return $this;
}
/**
* @param int $timeout Request timeout time for client in seconds
*
* @return ClientInterface
*/
public function setTimeout($timeout)
{
$this->timeout = $timeout;
return $this;
}
/**
* @param array $headers
*/
public function normalizeHeaders(&$headers)
{
// Normalize headers
array_walk(
$headers,
function (&$val, &$key) {
$key = ucfirst(strtolower($key));
$val = ucfirst(strtolower($key)) . ': ' . $val;
}
);
}
}

32
vendor/OAuth/Common/Http/Client/ClientInterface.php vendored
View File

@@ -1,32 +0,0 @@
<?php
namespace OAuth\Common\Http\Client;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
/**
* Any HTTP clients to be used with the library should implement this interface.
*/
interface ClientInterface
{
/**
* Any implementing HTTP providers should send a request to the provided endpoint with the parameters.
* They should return, in string form, the response body and throw an exception on error.
*
* @param UriInterface $endpoint
* @param mixed $requestBody
* @param array $extraHeaders
* @param string $method
*
* @return string
*
* @throws TokenResponseException
*/
public function retrieveResponse(
UriInterface $endpoint,
$requestBody,
array $extraHeaders = array(),
$method = 'POST'
);
}

142
vendor/OAuth/Common/Http/Client/CurlClient.php vendored
View File

@@ -1,142 +0,0 @@
<?php
namespace OAuth\Common\Http\Client;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Client implementation for cURL
*/
class CurlClient extends AbstractClient
{
/**
* If true, explicitly sets cURL to use SSL version 3. Use this if cURL
* compiles with GnuTLS SSL.
*
* @var bool
*/
private $forceSSL3 = false;
/**
* Additional parameters (as `key => value` pairs) to be passed to `curl_setopt`
*
* @var array
*/
private $parameters = array();
/**
* Additional `curl_setopt` parameters
*
* @param array $parameters
*/
public function setCurlParameters(array $parameters)
{
$this->parameters = $parameters;
}
/**
* @param bool $force
*
* @return CurlClient
*/
public function setForceSSL3($force)
{
$this->forceSSL3 = $force;
return $this;
}
/**
* Any implementing HTTP providers should send a request to the provided endpoint with the parameters.
* They should return, in string form, the response body and throw an exception on error.
*
* @param UriInterface $endpoint
* @param mixed $requestBody
* @param array $extraHeaders
* @param string $method
*
* @return string
*
* @throws TokenResponseException
* @throws \InvalidArgumentException
*/
public function retrieveResponse(
UriInterface $endpoint,
$requestBody,
array $extraHeaders = array(),
$method = 'POST'
) {
// Normalize method name
$method = strtoupper($method);
$this->normalizeHeaders($extraHeaders);
if ($method === 'GET' && !empty($requestBody)) {
throw new \InvalidArgumentException('No body expected for "GET" request.');
}
if (!isset($extraHeaders['Content-Type']) && $method === 'POST' && is_array($requestBody)) {
$extraHeaders['Content-Type'] = 'Content-Type: application/x-www-form-urlencoded';
}
$extraHeaders['Host'] = 'Host: '.$endpoint->getHost();
$extraHeaders['Connection'] = 'Connection: close';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $endpoint->getAbsoluteUri());
if ($method === 'POST' || $method === 'PUT') {
if ($requestBody && is_array($requestBody)) {
$requestBody = http_build_query($requestBody, '', '&');
}
if ($method === 'PUT') {
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
} else {
curl_setopt($ch, CURLOPT_POST, true);
}
curl_setopt($ch, CURLOPT_POSTFIELDS, $requestBody);
} else {
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
}
if ($this->maxRedirects > 0) {
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($ch, CURLOPT_MAXREDIRS, $this->maxRedirects);
}
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_HTTPHEADER, $extraHeaders);
curl_setopt($ch, CURLOPT_USERAGENT, $this->userAgent);
foreach ($this->parameters as $key => $value) {
curl_setopt($ch, $key, $value);
}
if ($this->forceSSL3) {
curl_setopt($ch, CURLOPT_SSLVERSION, 3);
}
$response = curl_exec($ch);
$responseCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if (false === $response) {
$errNo = curl_errno($ch);
$errStr = curl_error($ch);
curl_close($ch);
if (empty($errStr)) {
throw new TokenResponseException('Failed to request resource.', $responseCode);
}
throw new TokenResponseException('cURL Error # '.$errNo.': '.$errStr, $responseCode);
}
curl_close($ch);
return $response;
}
}

92
vendor/OAuth/Common/Http/Client/StreamClient.php vendored
View File

@@ -1,92 +0,0 @@
<?php
namespace OAuth\Common\Http\Client;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Client implementation for streams/file_get_contents
*/
class StreamClient extends AbstractClient
{
/**
* Any implementing HTTP providers should send a request to the provided endpoint with the parameters.
* They should return, in string form, the response body and throw an exception on error.
*
* @param UriInterface $endpoint
* @param mixed $requestBody
* @param array $extraHeaders
* @param string $method
*
* @return string
*
* @throws TokenResponseException
* @throws \InvalidArgumentException
*/
public function retrieveResponse(
UriInterface $endpoint,
$requestBody,
array $extraHeaders = array(),
$method = 'POST'
) {
// Normalize method name
$method = strtoupper($method);
$this->normalizeHeaders($extraHeaders);
if ($method === 'GET' && !empty($requestBody)) {
throw new \InvalidArgumentException('No body expected for "GET" request.');
}
if (!isset($extraHeaders['Content-Type']) && $method === 'POST' && is_array($requestBody)) {
$extraHeaders['Content-Type'] = 'Content-Type: application/x-www-form-urlencoded';
}
$host = 'Host: '.$endpoint->getHost();
// Append port to Host if it has been specified
if ($endpoint->hasExplicitPortSpecified()) {
$host .= ':'.$endpoint->getPort();
}
$extraHeaders['Host'] = $host;
$extraHeaders['Connection'] = 'Connection: close';
if (is_array($requestBody)) {
$requestBody = http_build_query($requestBody, '', '&');
}
$extraHeaders['Content-length'] = 'Content-length: '.strlen($requestBody);
$context = $this->generateStreamContext($requestBody, $extraHeaders, $method);
$level = error_reporting(0);
$response = file_get_contents($endpoint->getAbsoluteUri(), false, $context);
error_reporting($level);
if (false === $response) {
$lastError = error_get_last();
if (is_null($lastError)) {
throw new TokenResponseException('Failed to request resource.');
}
throw new TokenResponseException($lastError['message']);
}
return $response;
}
private function generateStreamContext($body, $headers, $method)
{
return stream_context_create(
array(
'http' => array(
'method' => $method,
'header' => implode("\r\n", array_values($headers)),
'content' => $body,
'protocol_version' => '1.1',
'user_agent' => $this->userAgent,
'max_redirects' => $this->maxRedirects,
'timeout' => $this->timeout
),
)
);
}
}

12
vendor/OAuth/Common/Http/Exception/TokenResponseException.php vendored
View File

@@ -1,12 +0,0 @@
<?php
namespace OAuth\Common\Http\Exception;
use OAuth\Common\Exception\Exception;
/**
* Exception relating to token response from service.
*/
class TokenResponseException extends Exception
{
}

408
vendor/OAuth/Common/Http/Uri/Uri.php vendored
View File

@@ -1,408 +0,0 @@
<?php
namespace OAuth\Common\Http\Uri;
use InvalidArgumentException;
/**
* Standards-compliant URI class.
*/
class Uri implements UriInterface
{
/**
* @var string
*/
private $scheme = 'http';
/**
* @var string
*/
private $userInfo = '';
/**
* @var string
*/
private $rawUserInfo = '';
/**
* @var string
*/
private $host;
/**
* @var int
*/
private $port = 80;
/**
* @var string
*/
private $path = '/';
/**
* @var string
*/
private $query = '';
/**
* @var string
*/
private $fragment = '';
/**
* @var bool
*/
private $explicitPortSpecified = false;
/**
* @var bool
*/
private $explicitTrailingHostSlash = false;
/**
* @param string $uri
*/
public function __construct($uri = null)
{
if (null !== $uri) {
$this->parseUri($uri);
}
}
/**
* @param string $uri
*
* @throws \InvalidArgumentException
*/
protected function parseUri($uri)
{
if (false === ($uriParts = parse_url($uri))) {
// congratulations if you've managed to get parse_url to fail,
// it seems to always return some semblance of a parsed url no matter what
throw new InvalidArgumentException("Invalid URI: $uri");
}
if (!isset($uriParts['scheme'])) {
throw new InvalidArgumentException('Invalid URI: http|https scheme required');
}
$this->scheme = $uriParts['scheme'];
$this->host = $uriParts['host'];
if (isset($uriParts['port'])) {
$this->port = $uriParts['port'];
$this->explicitPortSpecified = true;
} else {
$this->port = strcmp('https', $uriParts['scheme']) ? 80 : 443;
$this->explicitPortSpecified = false;
}
if (isset($uriParts['path'])) {
$this->path = $uriParts['path'];
if ('/' === $uriParts['path']) {
$this->explicitTrailingHostSlash = true;
}
} else {
$this->path = '/';
}
$this->query = isset($uriParts['query']) ? $uriParts['query'] : '';
$this->fragment = isset($uriParts['fragment']) ? $uriParts['fragment'] : '';
$userInfo = '';
if (!empty($uriParts['user'])) {
$userInfo .= $uriParts['user'];
}
if ($userInfo && !empty($uriParts['pass'])) {
$userInfo .= ':' . $uriParts['pass'];
}
$this->setUserInfo($userInfo);
}
/**
* @param string $rawUserInfo
*
* @return string
*/
protected function protectUserInfo($rawUserInfo)
{
$colonPos = strpos($rawUserInfo, ':');
// rfc3986-3.2.1 | http://tools.ietf.org/html/rfc3986#section-3.2
// "Applications should not render as clear text any data
// after the first colon (":") character found within a userinfo
// subcomponent unless the data after the colon is the empty string
// (indicating no password)"
if ($colonPos !== false && strlen($rawUserInfo)-1 > $colonPos) {
return substr($rawUserInfo, 0, $colonPos) . ':********';
} else {
return $rawUserInfo;
}
}
/**
* @return string
*/
public function getScheme()
{
return $this->scheme;
}
/**
* @return string
*/
public function getUserInfo()
{
return $this->userInfo;
}
/**
* @return string
*/
public function getRawUserInfo()
{
return $this->rawUserInfo;
}
/**
* @return string
*/
public function getHost()
{
return $this->host;
}
/**
* @return int
*/
public function getPort()
{
return $this->port;
}
/**
* @return string
*/
public function getPath()
{
return $this->path;
}
/**
* @return string
*/
public function getQuery()
{
return $this->query;
}
/**
* @return string
*/
public function getFragment()
{
return $this->fragment;
}
/**
* Uses protected user info by default as per rfc3986-3.2.1
* Uri::getRawAuthority() is available if plain-text password information is desirable.
*
* @return string
*/
public function getAuthority()
{
$authority = $this->userInfo ? $this->userInfo.'@' : '';
$authority .= $this->host;
if ($this->explicitPortSpecified) {
$authority .= ":{$this->port}";
}
return $authority;
}
/**
* @return string
*/
public function getRawAuthority()
{
$authority = $this->rawUserInfo ? $this->rawUserInfo.'@' : '';
$authority .= $this->host;
if ($this->explicitPortSpecified) {
$authority .= ":{$this->port}";
}
return $authority;
}
/**
* @return string
*/
public function getAbsoluteUri()
{
$uri = $this->scheme . '://' . $this->getRawAuthority();
if ('/' === $this->path) {
$uri .= $this->explicitTrailingHostSlash ? '/' : '';
} else {
$uri .= $this->path;
}
if (!empty($this->query)) {
$uri .= "?{$this->query}";
}
if (!empty($this->fragment)) {
$uri .= "#{$this->fragment}";
}
return $uri;
}
/**
* @return string
*/
public function getRelativeUri()
{
$uri = '';
if ('/' === $this->path) {
$uri .= $this->explicitTrailingHostSlash ? '/' : '';
} else {
$uri .= $this->path;
}
return $uri;
}
/**
* Uses protected user info by default as per rfc3986-3.2.1
* Uri::getAbsoluteUri() is available if plain-text password information is desirable.
*
* @return string
*/
public function __toString()
{
$uri = $this->scheme . '://' . $this->getAuthority();
if ('/' === $this->path) {
$uri .= $this->explicitTrailingHostSlash ? '/' : '';
} else {
$uri .= $this->path;
}
if (!empty($this->query)) {
$uri .= "?{$this->query}";
}
if (!empty($this->fragment)) {
$uri .= "#{$this->fragment}";
}
return $uri;
}
/**
* @param $path
*/
public function setPath($path)
{
if (empty($path)) {
$this->path = '/';
$this->explicitTrailingHostSlash = false;
} else {
$this->path = $path;
if ('/' === $this->path) {
$this->explicitTrailingHostSlash = true;
}
}
}
/**
* @param string $query
*/
public function setQuery($query)
{
$this->query = $query;
}
/**
* @param string $var
* @param string $val
*/
public function addToQuery($var, $val)
{
if (strlen($this->query) > 0) {
$this->query .= '&';
}
$this->query .= http_build_query(array($var => $val), '', '&');
}
/**
* @param string $fragment
*/
public function setFragment($fragment)
{
$this->fragment = $fragment;
}
/**
* @param string $scheme
*/
public function setScheme($scheme)
{
$this->scheme = $scheme;
}
/**
* @param string $userInfo
*/
public function setUserInfo($userInfo)
{
$this->userInfo = $userInfo ? $this->protectUserInfo($userInfo) : '';
$this->rawUserInfo = $userInfo;
}
/**
* @param int $port
*/
public function setPort($port)
{
$this->port = intval($port);
if (('https' === $this->scheme && $this->port === 443) || ('http' === $this->scheme && $this->port === 80)) {
$this->explicitPortSpecified = false;
} else {
$this->explicitPortSpecified = true;
}
}
/**
* @param string $host
*/
public function setHost($host)
{
$this->host = $host;
}
/**
* @return bool
*/
public function hasExplicitTrailingHostSlash()
{
return $this->explicitTrailingHostSlash;
}
/**
* @return bool
*/
public function hasExplicitPortSpecified()
{
return $this->explicitPortSpecified;
}
}

168
vendor/OAuth/Common/Http/Uri/UriFactory.php vendored
View File

@@ -1,168 +0,0 @@
<?php
namespace OAuth\Common\Http\Uri;
use RuntimeException;
/**
* Factory class for uniform resource indicators
*/
class UriFactory implements UriFactoryInterface
{
/**
* Factory method to build a URI from a super-global $_SERVER array.
*
* @param array $_server
*
* @return UriInterface
*/
public function createFromSuperGlobalArray(array $_server)
{
if ($uri = $this->attemptProxyStyleParse($_server)) {
return $uri;
}
$scheme = $this->detectScheme($_server);
$host = $this->detectHost($_server);
$port = $this->detectPort($_server);
$path = $this->detectPath($_server);
$query = $this->detectQuery($_server);
return $this->createFromParts($scheme, '', $host, $port, $path, $query);
}
/**
* @param string $absoluteUri
*
* @return UriInterface
*/
public function createFromAbsolute($absoluteUri)
{
return new Uri($absoluteUri);
}
/**
* Factory method to build a URI from parts
*
* @param string $scheme
* @param string $userInfo
* @param string $host
* @param string $port
* @param string $path
* @param string $query
* @param string $fragment
*
* @return UriInterface
*/
public function createFromParts($scheme, $userInfo, $host, $port, $path = '', $query = '', $fragment = '')
{
$uri = new Uri();
$uri->setScheme($scheme);
$uri->setUserInfo($userInfo);
$uri->setHost($host);
$uri->setPort($port);
$uri->setPath($path);
$uri->setQuery($query);
$uri->setFragment($fragment);
return $uri;
}
/**
* @param array $_server
*
* @return UriInterface|null
*/
private function attemptProxyStyleParse($_server)
{
// If the raw HTTP request message arrives with a proxy-style absolute URI in the
// initial request line, the absolute URI is stored in $_SERVER['REQUEST_URI'] and
// we only need to parse that.
if (isset($_server['REQUEST_URI']) && parse_url($_server['REQUEST_URI'], PHP_URL_SCHEME)) {
return new Uri($_server['REQUEST_URI']);
}
return null;
}
/**
* @param array $_server
*
* @return string
*
* @throws RuntimeException
*/
private function detectPath($_server)
{
if (isset($_server['REQUEST_URI'])) {
$uri = $_server['REQUEST_URI'];
} elseif (isset($_server['REDIRECT_URL'])) {
$uri = $_server['REDIRECT_URL'];
} else {
throw new RuntimeException('Could not detect URI path from superglobal');
}
$queryStr = strpos($uri, '?');
if ($queryStr !== false) {
$uri = substr($uri, 0, $queryStr);
}
return $uri;
}
/**
* @param array $_server
*
* @return string
*/
private function detectHost(array $_server)
{
$host = isset($_server['HTTP_HOST']) ? $_server['HTTP_HOST'] : '';
if (strstr($host, ':')) {
$host = parse_url($host, PHP_URL_HOST);
}
return $host;
}
/**
* @param array $_server
*
* @return string
*/
private function detectPort(array $_server)
{
return isset($_server['SERVER_PORT']) ? $_server['SERVER_PORT'] : 80;
}
/**
* @param array $_server
*
* @return string
*/
private function detectQuery(array $_server)
{
return isset($_server['QUERY_STRING']) ? $_server['QUERY_STRING'] : '';
}
/**
* Determine URI scheme component from superglobal array
*
* When using ISAPI with IIS, the value will be "off" if the request was
* not made through the HTTPS protocol. As a result, we filter the
* value to a bool.
*
* @param array $_server A super-global $_SERVER array
*
* @return string Returns http or https depending on the URI scheme
*/
private function detectScheme(array $_server)
{
if (isset($_server['HTTPS']) && filter_var($_server['HTTPS'], FILTER_VALIDATE_BOOLEAN)) {
return 'https';
} else {
return 'http';
}
}
}

42
vendor/OAuth/Common/Http/Uri/UriFactoryInterface.php vendored
View File

@@ -1,42 +0,0 @@
<?php
namespace OAuth\Common\Http\Uri;
/**
* Factory interface for uniform resource indicators
*/
interface UriFactoryInterface
{
/**
* Factory method to build a URI from a super-global $_SERVER array.
*
* @param array $_server
*
* @return UriInterface
*/
public function createFromSuperGlobalArray(array $_server);
/**
* Creates a URI from an absolute URI
*
* @param string $absoluteUri
*
* @return UriInterface
*/
public function createFromAbsolute($absoluteUri);
/**
* Factory method to build a URI from parts
*
* @param string $scheme
* @param string $userInfo
* @param string $host
* @param string $port
* @param string $path
* @param string $query
* @param string $fragment
*
* @return UriInterface
*/
public function createFromParts($scheme, $userInfo, $host, $port, $path = '', $query = '', $fragment = '');
}

133
vendor/OAuth/Common/Http/Uri/UriInterface.php vendored
View File

@@ -1,133 +0,0 @@
<?php
namespace OAuth\Common\Http\Uri;
interface UriInterface
{
/**
* @return string
*/
public function getScheme();
/**
* @param string $scheme
*/
public function setScheme($scheme);
/**
* @return string
*/
public function getHost();
/**
* @param string $host
*/
public function setHost($host);
/**
* @return int
*/
public function getPort();
/**
* @param int $port
*/
public function setPort($port);
/**
* @return string
*/
public function getPath();
/**
* @param string $path
*/
public function setPath($path);
/**
* @return string
*/
public function getQuery();
/**
* @param string $query
*/
public function setQuery($query);
/**
* Adds a param to the query string.
*
* @param string $var
* @param string $val
*/
public function addToQuery($var, $val);
/**
* @return string
*/
public function getFragment();
/**
* Should return URI user info, masking protected user info data according to rfc3986-3.2.1
*
* @return string
*/
public function getUserInfo();
/**
* @param string $userInfo
*/
public function setUserInfo($userInfo);
/**
* Should return the URI Authority, masking protected user info data according to rfc3986-3.2.1
*
* @return string
*/
public function getAuthority();
/**
* Should return the URI string, masking protected user info data according to rfc3986-3.2.1
*
* @return string the URI string with user protected info masked
*/
public function __toString();
/**
* Should return the URI Authority without masking protected user info data
*
* @return string
*/
public function getRawAuthority();
/**
* Should return the URI user info without masking protected user info data
*
* @return string
*/
public function getRawUserInfo();
/**
* Build the full URI based on all the properties
*
* @return string The full URI without masking user info
*/
public function getAbsoluteUri();
/**
* Build the relative URI based on all the properties
*
* @return string The relative URI
*/
public function getRelativeUri();
/**
* @return bool
*/
public function hasExplicitTrailingHostSlash();
/**
* @return bool
*/
public function hasExplicitPortSpecified();
}

100
vendor/OAuth/Common/Service/AbstractService.php vendored
View File

@@ -1,100 +0,0 @@
<?php
namespace OAuth\Common\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Exception\Exception;
use OAuth\Common\Storage\TokenStorageInterface;
/**
* Abstract OAuth service, version-agnostic
*/
abstract class AbstractService implements ServiceInterface
{
/** @var Credentials */
protected $credentials;
/** @var ClientInterface */
protected $httpClient;
/** @var TokenStorageInterface */
protected $storage;
/**
* @param CredentialsInterface $credentials
* @param ClientInterface $httpClient
* @param TokenStorageInterface $storage
*/
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage
) {
$this->credentials = $credentials;
$this->httpClient = $httpClient;
$this->storage = $storage;
}
/**
* @param UriInterface|string $path
* @param UriInterface $baseApiUri
*
* @return UriInterface
*
* @throws Exception
*/
protected function determineRequestUriFromPath($path, UriInterface $baseApiUri = null)
{
if ($path instanceof UriInterface) {
$uri = $path;
} elseif (stripos($path, 'http://') === 0 || stripos($path, 'https://') === 0) {
$uri = new Uri($path);
} else {
if (null === $baseApiUri) {
throw new Exception(
'An absolute URI must be passed to ServiceInterface::request as no baseApiUri is set.'
);
}
$uri = clone $baseApiUri;
if (false !== strpos($path, '?')) {
$parts = explode('?', $path, 2);
$path = $parts[0];
$query = $parts[1];
$uri->setQuery($query);
}
if ($path[0] === '/') {
$path = substr($path, 1);
}
$uri->setPath($uri->getPath() . $path);
}
return $uri;
}
/**
* Accessor to the storage adapter to be able to retrieve tokens
*
* @return TokenStorageInterface
*/
public function getStorage()
{
return $this->storage;
}
/**
* @return string
*/
public function service()
{
// get class name without backslashes
$classname = get_class($this);
return preg_replace('/^.*\\\\/', '', $classname);
}
}

49
vendor/OAuth/Common/Service/ServiceInterface.php vendored
View File

@@ -1,49 +0,0 @@
<?php
namespace OAuth\Common\Service;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Defines methods common among all OAuth services.
*/
interface ServiceInterface
{
/**
* Sends an authenticated API request to the path provided.
* If the path provided is not an absolute URI, the base API Uri (service-specific) will be used.
*
* @param string|UriInterface $path
* @param string $method HTTP method
* @param array $body Request body if applicable (an associative array will
* automatically be converted into a urlencoded body)
* @param array $extraHeaders Extra headers if applicable. These will override service-specific
* any defaults.
*
* @return string
*/
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array());
/**
* Returns the url to redirect to for authorization purposes.
*
* @param array $additionalParameters
*
* @return UriInterface
*/
public function getAuthorizationUri(array $additionalParameters = array());
/**
* Returns the authorization API endpoint.
*
* @return UriInterface
*/
public function getAuthorizationEndpoint();
/**
* Returns the access token API endpoint.
*
* @return UriInterface
*/
public function getAccessTokenEndpoint();
}

10
vendor/OAuth/Common/Storage/Exception/AuthorizationStateNotFoundException.php vendored
View File

@@ -1,10 +0,0 @@
<?php
namespace OAuth\Common\Storage\Exception;
/**
* Exception thrown when a state is not found in storage.
*/
class AuthorizationStateNotFoundException extends StorageException
{
}

12
vendor/OAuth/Common/Storage/Exception/StorageException.php vendored
View File

@@ -1,12 +0,0 @@
<?php
namespace OAuth\Common\Storage\Exception;
use OAuth\Common\Exception\Exception;
/**
* Generic storage exception.
*/
class StorageException extends Exception
{
}

10
vendor/OAuth/Common/Storage/Exception/TokenNotFoundException.php vendored
View File

@@ -1,10 +0,0 @@
<?php
namespace OAuth\Common\Storage\Exception;
/**
* Exception thrown when a token is not found in storage.
*/
class TokenNotFoundException extends StorageException
{
}

139
vendor/OAuth/Common/Storage/Memory.php vendored
View File

@@ -1,139 +0,0 @@
<?php
namespace OAuth\Common\Storage;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
/*
* Stores a token in-memory only (destroyed at end of script execution).
*/
class Memory implements TokenStorageInterface
{
/**
* @var object|TokenInterface
*/
protected $tokens;
/**
* @var array
*/
protected $states;
public function __construct()
{
$this->tokens = array();
$this->states = array();
}
/**
* {@inheritDoc}
*/
public function retrieveAccessToken($service)
{
if ($this->hasAccessToken($service)) {
return $this->tokens[$service];
}
throw new TokenNotFoundException('Token not stored');
}
/**
* {@inheritDoc}
*/
public function storeAccessToken($service, TokenInterface $token)
{
$this->tokens[$service] = $token;
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAccessToken($service)
{
return isset($this->tokens[$service]) && $this->tokens[$service] instanceof TokenInterface;
}
/**
* {@inheritDoc}
*/
public function clearToken($service)
{
if (array_key_exists($service, $this->tokens)) {
unset($this->tokens[$service]);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllTokens()
{
$this->tokens = array();
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function retrieveAuthorizationState($service)
{
if ($this->hasAuthorizationState($service)) {
return $this->states[$service];
}
throw new AuthorizationStateNotFoundException('State not stored');
}
/**
* {@inheritDoc}
*/
public function storeAuthorizationState($service, $state)
{
$this->states[$service] = $state;
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAuthorizationState($service)
{
return isset($this->states[$service]) && null !== $this->states[$service];
}
/**
* {@inheritDoc}
*/
public function clearAuthorizationState($service)
{
if (array_key_exists($service, $this->states)) {
unset($this->states[$service]);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllAuthorizationStates()
{
$this->states = array();
// allow chaining
return $this;
}
}

230
vendor/OAuth/Common/Storage/Redis.php vendored
View File

@@ -1,230 +0,0 @@
<?php
namespace OAuth\Common\Storage;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
use Predis\Client as Predis;
/*
* Stores a token in a Redis server. Requires the Predis library available at https://github.com/nrk/predis
*/
class Redis implements TokenStorageInterface
{
/**
* @var string
*/
protected $key;
protected $stateKey;
/**
* @var object|\Redis
*/
protected $redis;
/**
* @var object|TokenInterface
*/
protected $cachedTokens;
/**
* @var object
*/
protected $cachedStates;
/**
* @param Predis $redis An instantiated and connected redis client
* @param string $key The key to store the token under in redis
* @param string $stateKey The key to store the state under in redis.
*/
public function __construct(Predis $redis, $key, $stateKey)
{
$this->redis = $redis;
$this->key = $key;
$this->stateKey = $stateKey;
$this->cachedTokens = array();
$this->cachedStates = array();
}
/**
* {@inheritDoc}
*/
public function retrieveAccessToken($service)
{
if (!$this->hasAccessToken($service)) {
throw new TokenNotFoundException('Token not found in redis');
}
if (isset($this->cachedTokens[$service])) {
return $this->cachedTokens[$service];
}
$val = $this->redis->hget($this->key, $service);
return $this->cachedTokens[$service] = unserialize($val);
}
/**
* {@inheritDoc}
*/
public function storeAccessToken($service, TokenInterface $token)
{
// (over)write the token
$this->redis->hset($this->key, $service, serialize($token));
$this->cachedTokens[$service] = $token;
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAccessToken($service)
{
if (isset($this->cachedTokens[$service])
&& $this->cachedTokens[$service] instanceof TokenInterface
) {
return true;
}
return $this->redis->hexists($this->key, $service);
}
/**
* {@inheritDoc}
*/
public function clearToken($service)
{
$this->redis->hdel($this->key, $service);
unset($this->cachedTokens[$service]);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllTokens()
{
// memory
$this->cachedTokens = array();
// redis
$keys = $this->redis->hkeys($this->key);
$me = $this; // 5.3 compat
// pipeline for performance
$this->redis->pipeline(
function ($pipe) use ($keys, $me) {
foreach ($keys as $k) {
$pipe->hdel($me->getKey(), $k);
}
}
);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function retrieveAuthorizationState($service)
{
if (!$this->hasAuthorizationState($service)) {
throw new AuthorizationStateNotFoundException('State not found in redis');
}
if (isset($this->cachedStates[$service])) {
return $this->cachedStates[$service];
}
$val = $this->redis->hget($this->stateKey, $service);
return $this->cachedStates[$service] = unserialize($val);
}
/**
* {@inheritDoc}
*/
public function storeAuthorizationState($service, $state)
{
// (over)write the token
$this->redis->hset($this->stateKey, $service, $state);
$this->cachedStates[$service] = $state;
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAuthorizationState($service)
{
if (isset($this->cachedStates[$service])
&& null !== $this->cachedStates[$service]
) {
return true;
}
return $this->redis->hexists($this->stateKey, $service);
}
/**
* {@inheritDoc}
*/
public function clearAuthorizationState($service)
{
$this->redis->hdel($this->stateKey, $service);
unset($this->cachedStates[$service]);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllAuthorizationStates()
{
// memory
$this->cachedStates = array();
// redis
$keys = $this->redis->hkeys($this->stateKey);
$me = $this; // 5.3 compat
// pipeline for performance
$this->redis->pipeline(
function ($pipe) use ($keys, $me) {
foreach ($keys as $k) {
$pipe->hdel($me->getKey(), $k);
}
}
);
// allow chaining
return $this;
}
/**
* @return Predis $redis
*/
public function getRedis()
{
return $this->redis;
}
/**
* @return string $key
*/
public function getKey()
{
return $this->key;
}
}

188
vendor/OAuth/Common/Storage/Session.php vendored
View File

@@ -1,188 +0,0 @@
<?php
namespace OAuth\Common\Storage;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
/**
* Stores a token in a PHP session.
*/
class Session implements TokenStorageInterface
{
/**
* @var bool
*/
protected $startSession;
/**
* @var string
*/
protected $sessionVariableName;
/**
* @var string
*/
protected $stateVariableName;
/**
* @param bool $startSession Whether or not to start the session upon construction.
* @param string $sessionVariableName the variable name to use within the _SESSION superglobal
* @param string $stateVariableName
*/
public function __construct(
$startSession = true,
$sessionVariableName = 'lusitanian_oauth_token',
$stateVariableName = 'lusitanian_oauth_state'
) {
if ($startSession && !isset($_SESSION)) {
session_start();
}
$this->startSession = $startSession;
$this->sessionVariableName = $sessionVariableName;
$this->stateVariableName = $stateVariableName;
if (!isset($_SESSION[$sessionVariableName])) {
$_SESSION[$sessionVariableName] = array();
}
if (!isset($_SESSION[$stateVariableName])) {
$_SESSION[$stateVariableName] = array();
}
}
/**
* {@inheritDoc}
*/
public function retrieveAccessToken($service)
{
if ($this->hasAccessToken($service)) {
return unserialize($_SESSION[$this->sessionVariableName][$service]);
}
throw new TokenNotFoundException('Token not found in session, are you sure you stored it?');
}
/**
* {@inheritDoc}
*/
public function storeAccessToken($service, TokenInterface $token)
{
$serializedToken = serialize($token);
if (isset($_SESSION[$this->sessionVariableName])
&& is_array($_SESSION[$this->sessionVariableName])
) {
$_SESSION[$this->sessionVariableName][$service] = $serializedToken;
} else {
$_SESSION[$this->sessionVariableName] = array(
$service => $serializedToken,
);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAccessToken($service)
{
return isset($_SESSION[$this->sessionVariableName], $_SESSION[$this->sessionVariableName][$service]);
}
/**
* {@inheritDoc}
*/
public function clearToken($service)
{
if (array_key_exists($service, $_SESSION[$this->sessionVariableName])) {
unset($_SESSION[$this->sessionVariableName][$service]);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllTokens()
{
unset($_SESSION[$this->sessionVariableName]);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function storeAuthorizationState($service, $state)
{
if (isset($_SESSION[$this->stateVariableName])
&& is_array($_SESSION[$this->stateVariableName])
) {
$_SESSION[$this->stateVariableName][$service] = $state;
} else {
$_SESSION[$this->stateVariableName] = array(
$service => $state,
);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAuthorizationState($service)
{
return isset($_SESSION[$this->stateVariableName], $_SESSION[$this->stateVariableName][$service]);
}
/**
* {@inheritDoc}
*/
public function retrieveAuthorizationState($service)
{
if ($this->hasAuthorizationState($service)) {
return $_SESSION[$this->stateVariableName][$service];
}
throw new AuthorizationStateNotFoundException('State not found in session, are you sure you stored it?');
}
/**
* {@inheritDoc}
*/
public function clearAuthorizationState($service)
{
if (array_key_exists($service, $_SESSION[$this->stateVariableName])) {
unset($_SESSION[$this->stateVariableName][$service]);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllAuthorizationStates()
{
unset($_SESSION[$this->stateVariableName]);
// allow chaining
return $this;
}
public function __destruct()
{
if ($this->startSession) {
session_write_close();
}
}
}

200
vendor/OAuth/Common/Storage/SymfonySession.php vendored
View File

@@ -1,200 +0,0 @@
<?php
namespace OAuth\Common\Storage;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
class SymfonySession implements TokenStorageInterface
{
private $session;
private $sessionVariableName;
private $stateVariableName;
/**
* @param SessionInterface $session
* @param bool $startSession
* @param string $sessionVariableName
* @param string $stateVariableName
*/
public function __construct(
SessionInterface $session,
$startSession = true,
$sessionVariableName = 'lusitanian_oauth_token',
$stateVariableName = 'lusitanian_oauth_state'
) {
$this->session = $session;
$this->sessionVariableName = $sessionVariableName;
$this->stateVariableName = $stateVariableName;
}
/**
* {@inheritDoc}
*/
public function retrieveAccessToken($service)
{
if ($this->hasAccessToken($service)) {
// get from session
$tokens = $this->session->get($this->sessionVariableName);
// one item
return $tokens[$service];
}
throw new TokenNotFoundException('Token not found in session, are you sure you stored it?');
}
/**
* {@inheritDoc}
*/
public function storeAccessToken($service, TokenInterface $token)
{
// get previously saved tokens
$tokens = $this->session->get($this->sessionVariableName);
if (!is_array($tokens)) {
$tokens = array();
}
$tokens[$service] = $token;
// save
$this->session->set($this->sessionVariableName, $tokens);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAccessToken($service)
{
// get from session
$tokens = $this->session->get($this->sessionVariableName);
return is_array($tokens)
&& isset($tokens[$service])
&& $tokens[$service] instanceof TokenInterface;
}
/**
* {@inheritDoc}
*/
public function clearToken($service)
{
// get previously saved tokens
$tokens = $this->session->get($this->sessionVariableName);
if (is_array($tokens) && array_key_exists($service, $tokens)) {
unset($tokens[$service]);
// Replace the stored tokens array
$this->session->set($this->sessionVariableName, $tokens);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllTokens()
{
$this->session->remove($this->sessionVariableName);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function retrieveAuthorizationState($service)
{
if ($this->hasAuthorizationState($service)) {
// get from session
$states = $this->session->get($this->stateVariableName);
// one item
return $states[$service];
}
throw new AuthorizationStateNotFoundException('State not found in session, are you sure you stored it?');
}
/**
* {@inheritDoc}
*/
public function storeAuthorizationState($service, $state)
{
// get previously saved tokens
$states = $this->session->get($this->stateVariableName);
if (!is_array($states)) {
$states = array();
}
$states[$service] = $state;
// save
$this->session->set($this->stateVariableName, $states);
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function hasAuthorizationState($service)
{
// get from session
$states = $this->session->get($this->stateVariableName);
return is_array($states)
&& isset($states[$service])
&& null !== $states[$service];
}
/**
* {@inheritDoc}
*/
public function clearAuthorizationState($service)
{
// get previously saved tokens
$states = $this->session->get($this->stateVariableName);
if (is_array($states) && array_key_exists($service, $states)) {
unset($states[$service]);
// Replace the stored tokens array
$this->session->set($this->stateVariableName, $states);
}
// allow chaining
return $this;
}
/**
* {@inheritDoc}
*/
public function clearAllAuthorizationStates()
{
$this->session->remove($this->stateVariableName);
// allow chaining
return $this;
}
/**
* @return Session
*/
public function getSession()
{
return $this->session;
}
}

98
vendor/OAuth/Common/Storage/TokenStorageInterface.php vendored
View File

@@ -1,98 +0,0 @@
<?php
namespace OAuth\Common\Storage;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
/**
* All token storage providers must implement this interface.
*/
interface TokenStorageInterface
{
/**
* @param string $service
*
* @return TokenInterface
*
* @throws TokenNotFoundException
*/
public function retrieveAccessToken($service);
/**
* @param string $service
* @param TokenInterface $token
*
* @return TokenStorageInterface
*/
public function storeAccessToken($service, TokenInterface $token);
/**
* @param string $service
*
* @return bool
*/
public function hasAccessToken($service);
/**
* Delete the users token. Aka, log out.
*
* @param string $service
*
* @return TokenStorageInterface
*/
public function clearToken($service);
/**
* Delete *ALL* user tokens. Use with care. Most of the time you will likely
* want to use clearToken() instead.
*
* @return TokenStorageInterface
*/
public function clearAllTokens();
/**
* Store the authorization state related to a given service
*
* @param string $service
* @param string $state
*
* @return TokenStorageInterface
*/
public function storeAuthorizationState($service, $state);
/**
* Check if an authorization state for a given service exists
*
* @param string $service
*
* @return bool
*/
public function hasAuthorizationState($service);
/**
* Retrieve the authorization state for a given service
*
* @param string $service
*
* @return string
*/
public function retrieveAuthorizationState($service);
/**
* Clear the authorization state of a given service
*
* @param string $service
*
* @return TokenStorageInterface
*/
public function clearAuthorizationState($service);
/**
* Delete *ALL* user authorization states. Use with care. Most of the time you will likely
* want to use clearAuthorization() instead.
*
* @return TokenStorageInterface
*/
public function clearAllAuthorizationStates();
}

128
vendor/OAuth/Common/Token/AbstractToken.php vendored
View File

@@ -1,128 +0,0 @@
<?php
namespace OAuth\Common\Token;
/**
* Base token implementation for any OAuth version.
*/
abstract class AbstractToken implements TokenInterface
{
/**
* @var string
*/
protected $accessToken;
/**
* @var string
*/
protected $refreshToken;
/**
* @var int
*/
protected $endOfLife;
/**
* @var array
*/
protected $extraParams = array();
/**
* @param string $accessToken
* @param string $refreshToken
* @param int $lifetime
* @param array $extraParams
*/
public function __construct($accessToken = null, $refreshToken = null, $lifetime = null, $extraParams = array())
{
$this->accessToken = $accessToken;
$this->refreshToken = $refreshToken;
$this->setLifetime($lifetime);
$this->extraParams = $extraParams;
}
/**
* @return string
*/
public function getAccessToken()
{
return $this->accessToken;
}
/**
* @return string
*/
public function getRefreshToken()
{
return $this->refreshToken;
}
/**
* @return int
*/
public function getEndOfLife()
{
return $this->endOfLife;
}
/**
* @param array $extraParams
*/
public function setExtraParams(array $extraParams)
{
$this->extraParams = $extraParams;
}
/**
* @return array
*/
public function getExtraParams()
{
return $this->extraParams;
}
/**
* @param string $accessToken
*/
public function setAccessToken($accessToken)
{
$this->accessToken = $accessToken;
}
/**
* @param int $endOfLife
*/
public function setEndOfLife($endOfLife)
{
$this->endOfLife = $endOfLife;
}
/**
* @param int $lifetime
*/
public function setLifetime($lifetime)
{
if (0 === $lifetime || static::EOL_NEVER_EXPIRES === $lifetime) {
$this->endOfLife = static::EOL_NEVER_EXPIRES;
} elseif (null !== $lifetime) {
$this->endOfLife = intval($lifetime) + time();
} else {
$this->endOfLife = static::EOL_UNKNOWN;
}
}
/**
* @param string $refreshToken
*/
public function setRefreshToken($refreshToken)
{
$this->refreshToken = $refreshToken;
}
public function isExpired()
{
return ($this->getEndOfLife() !== TokenInterface::EOL_NEVER_EXPIRES
&& $this->getEndOfLife() !== TokenInterface::EOL_UNKNOWN
&& time() > $this->getEndOfLife());
}
}

12
vendor/OAuth/Common/Token/Exception/ExpiredTokenException.php vendored
View File

@@ -1,12 +0,0 @@
<?php
namespace OAuth\Common\Token\Exception;
use OAuth\Common\Exception\Exception;
/**
* Exception thrown when an expired token is attempted to be used.
*/
class ExpiredTokenException extends Exception
{
}

64
vendor/OAuth/Common/Token/TokenInterface.php vendored
View File

@@ -1,64 +0,0 @@
<?php
namespace OAuth\Common\Token;
/**
* Base token interface for any OAuth version.
*/
interface TokenInterface
{
/**
* Denotes an unknown end of life time.
*/
const EOL_UNKNOWN = -9001;
/**
* Denotes a token which never expires, should only happen in OAuth1.
*/
const EOL_NEVER_EXPIRES = -9002;
/**
* @return string
*/
public function getAccessToken();
/**
* @return int
*/
public function getEndOfLife();
/**
* @return array
*/
public function getExtraParams();
/**
* @param string $accessToken
*/
public function setAccessToken($accessToken);
/**
* @param int $endOfLife
*/
public function setEndOfLife($endOfLife);
/**
* @param int $lifetime
*/
public function setLifetime($lifetime);
/**
* @param array $extraParams
*/
public function setExtraParams(array $extraParams);
/**
* @return string
*/
public function getRefreshToken();
/**
* @param string $refreshToken
*/
public function setRefreshToken($refreshToken);
}

305
vendor/OAuth/OAuth1/Service/AbstractService.php vendored
View File

@@ -1,305 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\TokenInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Service\AbstractService as BaseAbstractService;
abstract class AbstractService extends BaseAbstractService implements ServiceInterface
{
/** @const OAUTH_VERSION */
const OAUTH_VERSION = 1;
/** @var SignatureInterface */
protected $signature;
/** @var UriInterface|null */
protected $baseApiUri;
/**
* {@inheritDoc}
*/
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage);
$this->signature = $signature;
$this->baseApiUri = $baseApiUri;
$this->signature->setHashingAlgorithm($this->getSignatureMethod());
}
/**
* {@inheritDoc}
*/
public function requestRequestToken()
{
$authorizationHeader = array('Authorization' => $this->buildAuthorizationHeaderForTokenRequest());
$headers = array_merge($authorizationHeader, $this->getExtraOAuthHeaders());
$responseBody = $this->httpClient->retrieveResponse($this->getRequestTokenEndpoint(), array(), $headers);
$token = $this->parseRequestTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($additionalParameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritDoc}
*/
public function requestAccessToken($token, $verifier, $tokenSecret = null)
{
if (is_null($tokenSecret)) {
$storedRequestToken = $this->storage->retrieveAccessToken($this->service());
$tokenSecret = $storedRequestToken->getRequestTokenSecret();
}
$this->signature->setTokenSecret($tokenSecret);
$bodyParams = array(
'oauth_verifier' => $verifier,
);
$authorizationHeader = array(
'Authorization' => $this->buildAuthorizationHeaderForAPIRequest(
'POST',
$this->getAccessTokenEndpoint(),
$this->storage->retrieveAccessToken($this->service()),
$bodyParams
)
);
$headers = array_merge($authorizationHeader, $this->getExtraOAuthHeaders());
$responseBody = $this->httpClient->retrieveResponse($this->getAccessTokenEndpoint(), $bodyParams, $headers);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
/**
* Sends an authenticated API request to the path provided.
* If the path provided is not an absolute URI, the base API Uri (must be passed into constructor) will be used.
*
* @param string|UriInterface $path
* @param string $method HTTP method
* @param array $body Request body if applicable (key/value pairs)
* @param array $extraHeaders Extra headers if applicable.
* These will override service-specific any defaults.
*
* @return string
*/
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array())
{
$uri = $this->determineRequestUriFromPath($path, $this->baseApiUri);
/** @var $token StdOAuth1Token */
$token = $this->storage->retrieveAccessToken($this->service());
$extraHeaders = array_merge($this->getExtraApiHeaders(), $extraHeaders);
$authorizationHeader = array(
'Authorization' => $this->buildAuthorizationHeaderForAPIRequest($method, $uri, $token, $body)
);
$headers = array_merge($authorizationHeader, $extraHeaders);
return $this->httpClient->retrieveResponse($uri, $body, $headers, $method);
}
/**
* Return any additional headers always needed for this service implementation's OAuth calls.
*
* @return array
*/
protected function getExtraOAuthHeaders()
{
return array();
}
/**
* Return any additional headers always needed for this service implementation's API calls.
*
* @return array
*/
protected function getExtraApiHeaders()
{
return array();
}
/**
* Builds the authorization header for getting an access or request token.
*
* @param array $extraParameters
*
* @return string
*/
protected function buildAuthorizationHeaderForTokenRequest(array $extraParameters = array())
{
$parameters = $this->getBasicAuthorizationHeaderInfo();
$parameters = array_merge($parameters, $extraParameters);
$parameters['oauth_signature'] = $this->signature->getSignature(
$this->getRequestTokenEndpoint(),
$parameters,
'POST'
);
$authorizationHeader = 'OAuth ';
$delimiter = '';
foreach ($parameters as $key => $value) {
$authorizationHeader .= $delimiter . rawurlencode($key) . '="' . rawurlencode($value) . '"';
$delimiter = ', ';
}
return $authorizationHeader;
}
/**
* Builds the authorization header for an authenticated API request
*
* @param string $method
* @param UriInterface $uri The uri the request is headed
* @param TokenInterface $token
* @param array $bodyParams Request body if applicable (key/value pairs)
*
* @return string
*/
protected function buildAuthorizationHeaderForAPIRequest(
$method,
UriInterface $uri,
TokenInterface $token,
$bodyParams = null
) {
$this->signature->setTokenSecret($token->getAccessTokenSecret());
$parameters = $this->getBasicAuthorizationHeaderInfo();
if (isset($parameters['oauth_callback'])) {
unset($parameters['oauth_callback']);
}
$parameters = array_merge($parameters, array('oauth_token' => $token->getAccessToken()));
$parameters = (is_array($bodyParams)) ? array_merge($parameters, $bodyParams) : $parameters;
$parameters['oauth_signature'] = $this->signature->getSignature($uri, $parameters, $method);
$authorizationHeader = 'OAuth ';
$delimiter = '';
foreach ($parameters as $key => $value) {
$authorizationHeader .= $delimiter . rawurlencode($key) . '="' . rawurlencode($value) . '"';
$delimiter = ', ';
}
return $authorizationHeader;
}
/**
* Builds the authorization header array.
*
* @return array
*/
protected function getBasicAuthorizationHeaderInfo()
{
$dateTime = new \DateTime();
$headerParameters = array(
'oauth_callback' => $this->credentials->getCallbackUrl(),
'oauth_consumer_key' => $this->credentials->getConsumerId(),
'oauth_nonce' => $this->generateNonce(),
'oauth_signature_method' => $this->getSignatureMethod(),
'oauth_timestamp' => $dateTime->format('U'),
'oauth_version' => $this->getVersion(),
);
return $headerParameters;
}
/**
* Pseudo random string generator used to build a unique string to sign each request
*
* @param int $length
*
* @return string
*/
protected function generateNonce($length = 32)
{
$characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
$nonce = '';
$maxRand = strlen($characters)-1;
for ($i = 0; $i < $length; $i++) {
$nonce.= $characters[rand(0, $maxRand)];
}
return $nonce;
}
/**
* @return string
*/
protected function getSignatureMethod()
{
return 'HMAC-SHA1';
}
/**
* This returns the version used in the authorization header of the requests
*
* @return string
*/
protected function getVersion()
{
return '1.0';
}
/**
* Parses the request token response and returns a TokenInterface.
* This is only needed to verify the `oauth_callback_confirmed` parameter. The actual
* parsing logic is contained in the access token parser.
*
* @abstract
*
* @param string $responseBody
*
* @return TokenInterface
*
* @throws TokenResponseException
*/
abstract protected function parseRequestTokenResponse($responseBody);
/**
* Parses the access token response and returns a TokenInterface.
*
* @abstract
*
* @param string $responseBody
*
* @return TokenInterface
*
* @throws TokenResponseException
*/
abstract protected function parseAccessTokenResponse($responseBody);
}

96
vendor/OAuth/OAuth1/Service/BitBucket.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class BitBucket extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://bitbucket.org/api/1.0/');
}
}
/**
* {@inheritDoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://bitbucket.org/!api/1.0/oauth/request_token');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://bitbucket.org/!api/1.0/oauth/authenticate');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://bitbucket.org/!api/1.0/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

132
vendor/OAuth/OAuth1/Service/Etsy.php vendored
View File

@@ -1,132 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Etsy extends AbstractService
{
protected $scopes = array();
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://openapi.etsy.com/v2/');
}
}
/**
* {@inheritdoc}
*/
public function getRequestTokenEndpoint()
{
$uri = new Uri($this->baseApiUri . 'oauth/request_token');
$scopes = $this->getScopes();
if (count($scopes)) {
$uri->setQuery('scope=' . implode('%20', $scopes));
}
return $uri;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri($this->baseApiUri);
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri($this->baseApiUri . 'oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
/**
* Set the scopes for permissions
* @see https://www.etsy.com/developers/documentation/getting_started/oauth#section_permission_scopes
* @param array $scopes
*
* @return $this
*/
public function setScopes(array $scopes)
{
if (!is_array($scopes)) {
$scopes = array();
}
$this->scopes = $scopes;
return $this;
}
/**
* Return the defined scopes
* @return array
*/
public function getScopes()
{
return $this->scopes;
}
}

96
vendor/OAuth/OAuth1/Service/FitBit.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class FitBit extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.fitbit.com/1/');
}
}
/**
* {@inheritdoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://api.fitbit.com/oauth/request_token');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.fitbit.com/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.fitbit.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

91
vendor/OAuth/OAuth1/Service/Flickr.php vendored
View File

@@ -1,91 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Flickr extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if ($baseApiUri === null) {
$this->baseApiUri = new Uri('https://api.flickr.com/services/rest/');
}
}
public function getRequestTokenEndpoint()
{
return new Uri('https://www.flickr.com/services/oauth/request_token');
}
public function getAuthorizationEndpoint()
{
return new Uri('https://www.flickr.com/services/oauth/authorize');
}
public function getAccessTokenEndpoint()
{
return new Uri('https://www.flickr.com/services/oauth/access_token');
}
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] != 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if ($data === null || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array())
{
$uri = $this->determineRequestUriFromPath('/', $this->baseApiUri);
$uri->addToQuery('method', $path);
$token = $this->storage->retrieveAccessToken($this->service());
$extraHeaders = array_merge($this->getExtraApiHeaders(), $extraHeaders);
$authorizationHeader = array(
'Authorization' => $this->buildAuthorizationHeaderForAPIRequest($method, $uri, $token, $body)
);
$headers = array_merge($authorizationHeader, $extraHeaders);
return $this->httpClient->retrieveResponse($uri, $body, $headers, $method);
}
}

96
vendor/OAuth/OAuth1/Service/ScoopIt.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class ScoopIt extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://www.scoop.it/api/1/');
}
}
/**
* {@inheritDoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://www.scoop.it/oauth/request');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.scoop.it/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.scoop.it/oauth/access');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

45
vendor/OAuth/OAuth1/Service/ServiceInterface.php vendored
View File

@@ -1,45 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Service\ServiceInterface as BaseServiceInterface;
use OAuth\OAuth1\Signature\SignatureInterface;
/**
* Defines the common methods across OAuth 1 services.
*/
interface ServiceInterface extends BaseServiceInterface
{
/**
* Retrieves and stores/returns the OAuth1 request token obtained from the service.
*
* @return TokenInterface $token
*
* @throws TokenResponseException
*/
public function requestRequestToken();
/**
* Retrieves and stores/returns the OAuth1 access token after a successful authorization.
*
* @param string $token The request token from the callback.
* @param string $verifier
* @param string $tokenSecret
*
* @return TokenInterface $token
*
* @throws TokenResponseException
*/
public function requestAccessToken($token, $verifier, $tokenSecret);
/**
* @return UriInterface
*/
public function getRequestTokenEndpoint();
}

96
vendor/OAuth/OAuth1/Service/Tumblr.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Tumblr extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.tumblr.com/v2/');
}
}
/**
* {@inheritdoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://www.tumblr.com/oauth/request_token');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.tumblr.com/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.tumblr.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

121
vendor/OAuth/OAuth1/Service/Twitter.php vendored
View File

@@ -1,121 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Exception\Exception;
class Twitter extends AbstractService
{
const ENDPOINT_AUTHENTICATE = "https://api.twitter.com/oauth/authenticate";
const ENDPOINT_AUTHORIZE = "https://api.twitter.com/oauth/authorize";
protected $authorizationEndpoint = self::ENDPOINT_AUTHENTICATE;
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.twitter.com/1.1/');
}
}
/**
* {@inheritdoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://api.twitter.com/oauth/request_token');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
if ($this->authorizationEndpoint != self::ENDPOINT_AUTHENTICATE
&& $this->authorizationEndpoint != self::ENDPOINT_AUTHORIZE) {
$this->authorizationEndpoint = self::ENDPOINT_AUTHENTICATE;
}
return new Uri($this->authorizationEndpoint);
}
/**
* @param string $authorizationEndpoint
*
* @throws Exception
*/
public function setAuthorizationEndpoint($endpoint)
{
if ($endpoint != self::ENDPOINT_AUTHENTICATE && $endpoint != self::ENDPOINT_AUTHORIZE) {
throw new Exception(
sprintf("'%s' is not a correct Twitter authorization endpoint.", $endpoint)
);
}
$this->authorizationEndpoint = $endpoint;
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.twitter.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

96
vendor/OAuth/OAuth1/Service/Xing.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Xing extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.xing.com/v1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://api.xing.com/v1/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.xing.com/v1/access_token');
}
/**
* {@inheritdoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://api.xing.com/v1/request_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

96
vendor/OAuth/OAuth1/Service/Yahoo.php vendored
View File

@@ -1,96 +0,0 @@
<?php
namespace OAuth\OAuth1\Service;
use OAuth\OAuth1\Signature\SignatureInterface;
use OAuth\OAuth1\Token\StdOAuth1Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Yahoo extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
SignatureInterface $signature,
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $signature, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://social.yahooapis.com/v1/');
}
}
/**
* {@inheritDoc}
*/
public function getRequestTokenEndpoint()
{
return new Uri('https://api.login.yahoo.com/oauth/v2/get_request_token');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://api.login.yahoo.com/oauth/v2/request_auth');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.login.yahoo.com/oauth/v2/get_token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth1Token();
$token->setRequestToken($data['oauth_token']);
$token->setRequestTokenSecret($data['oauth_token_secret']);
$token->setAccessToken($data['oauth_token']);
$token->setAccessTokenSecret($data['oauth_token_secret']);
$token->setEndOfLife(StdOAuth1Token::EOL_NEVER_EXPIRES);
unset($data['oauth_token'], $data['oauth_token_secret']);
$token->setExtraParams($data);
return $token;
}
}

12
vendor/OAuth/OAuth1/Signature/Exception/UnsupportedHashAlgorithmException.php vendored
View File

@@ -1,12 +0,0 @@
<?php
namespace OAuth\OAuth1\Signature\Exception;
use OAuth\Common\Exception\Exception;
/**
* Thrown when an unsupported hash mechanism is requested in signature class.
*/
class UnsupportedHashAlgorithmException extends Exception
{
}

132
vendor/OAuth/OAuth1/Signature/Signature.php vendored
View File

@@ -1,132 +0,0 @@
<?php
namespace OAuth\OAuth1\Signature;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\OAuth1\Signature\Exception\UnsupportedHashAlgorithmException;
class Signature implements SignatureInterface
{
/**
* @var Credentials
*/
protected $credentials;
/**
* @var string
*/
protected $algorithm;
/**
* @var string
*/
protected $tokenSecret = null;
/**
* @param CredentialsInterface $credentials
*/
public function __construct(CredentialsInterface $credentials)
{
$this->credentials = $credentials;
}
/**
* @param string $algorithm
*/
public function setHashingAlgorithm($algorithm)
{
$this->algorithm = $algorithm;
}
/**
* @param string $token
*/
public function setTokenSecret($token)
{
$this->tokenSecret = $token;
}
/**
* @param UriInterface $uri
* @param array $params
* @param string $method
*
* @return string
*/
public function getSignature(UriInterface $uri, array $params, $method = 'POST')
{
parse_str($uri->getQuery(), $queryStringData);
foreach (array_merge($queryStringData, $params) as $key => $value) {
$signatureData[rawurlencode($key)] = rawurlencode($value);
}
ksort($signatureData);
// determine base uri
$baseUri = $uri->getScheme() . '://' . $uri->getRawAuthority();
if ('/' === $uri->getPath()) {
$baseUri .= $uri->hasExplicitTrailingHostSlash() ? '/' : '';
} else {
$baseUri .= $uri->getPath();
}
$baseString = strtoupper($method) . '&';
$baseString .= rawurlencode($baseUri) . '&';
$baseString .= rawurlencode($this->buildSignatureDataString($signatureData));
return base64_encode($this->hash($baseString));
}
/**
* @param array $signatureData
*
* @return string
*/
protected function buildSignatureDataString(array $signatureData)
{
$signatureString = '';
$delimiter = '';
foreach ($signatureData as $key => $value) {
$signatureString .= $delimiter . $key . '=' . $value;
$delimiter = '&';
}
return $signatureString;
}
/**
* @return string
*/
protected function getSigningKey()
{
$signingKey = rawurlencode($this->credentials->getConsumerSecret()) . '&';
if ($this->tokenSecret !== null) {
$signingKey .= rawurlencode($this->tokenSecret);
}
return $signingKey;
}
/**
* @param string $data
*
* @return string
*
* @throws UnsupportedHashAlgorithmException
*/
protected function hash($data)
{
switch (strtoupper($this->algorithm)) {
case 'HMAC-SHA1':
return hash_hmac('sha1', $data, $this->getSigningKey(), true);
default:
throw new UnsupportedHashAlgorithmException(
'Unsupported hashing algorithm (' . $this->algorithm . ') used.'
);
}
}
}

28
vendor/OAuth/OAuth1/Signature/SignatureInterface.php vendored
View File

@@ -1,28 +0,0 @@
<?php
namespace OAuth\OAuth1\Signature;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
interface SignatureInterface
{
/**
* @param string $algorithm
*/
public function setHashingAlgorithm($algorithm);
/**
* @param string $token
*/
public function setTokenSecret($token);
/**
* @param UriInterface $uri
* @param array $params
* @param string $method
*
* @return string
*/
public function getSignature(UriInterface $uri, array $params, $method = 'POST');
}

75
vendor/OAuth/OAuth1/Token/StdOAuth1Token.php vendored
View File

@@ -1,75 +0,0 @@
<?php
namespace OAuth\OAuth1\Token;
use OAuth\Common\Token\AbstractToken;
/**
* Standard OAuth1 token implementation.
* Implements OAuth\OAuth1\Token\TokenInterface in case of any OAuth1 specific features.
*/
class StdOAuth1Token extends AbstractToken implements TokenInterface
{
/**
* @var string
*/
protected $requestToken;
/**
* @var string
*/
protected $requestTokenSecret;
/**
* @var string
*/
protected $accessTokenSecret;
/**
* @param string $requestToken
*/
public function setRequestToken($requestToken)
{
$this->requestToken = $requestToken;
}
/**
* @return string
*/
public function getRequestToken()
{
return $this->requestToken;
}
/**
* @param string $requestTokenSecret
*/
public function setRequestTokenSecret($requestTokenSecret)
{
$this->requestTokenSecret = $requestTokenSecret;
}
/**
* @return string
*/
public function getRequestTokenSecret()
{
return $this->requestTokenSecret;
}
/**
* @param string $accessTokenSecret
*/
public function setAccessTokenSecret($accessTokenSecret)
{
$this->accessTokenSecret = $accessTokenSecret;
}
/**
* @return string
*/
public function getAccessTokenSecret()
{
return $this->accessTokenSecret;
}
}

41
vendor/OAuth/OAuth1/Token/TokenInterface.php vendored
View File

@@ -1,41 +0,0 @@
<?php
namespace OAuth\OAuth1\Token;
use OAuth\Common\Token\TokenInterface as BaseTokenInterface;
/**
* OAuth1 specific token interface
*/
interface TokenInterface extends BaseTokenInterface
{
/**
* @return string
*/
public function getAccessTokenSecret();
/**
* @param string $accessTokenSecret
*/
public function setAccessTokenSecret($accessTokenSecret);
/**
* @return string
*/
public function getRequestTokenSecret();
/**
* @param string $requestTokenSecret
*/
public function setRequestTokenSecret($requestTokenSecret);
/**
* @return string
*/
public function getRequestToken();
/**
* @param string $requestToken
*/
public function setRequestToken($requestToken);
}

333
vendor/OAuth/OAuth2/Service/AbstractService.php vendored
View File

@@ -1,333 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Exception\Exception;
use OAuth\Common\Service\AbstractService as BaseAbstractService;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\OAuth2\Service\Exception\InvalidAuthorizationStateException;
use OAuth\OAuth2\Service\Exception\InvalidScopeException;
use OAuth\OAuth2\Service\Exception\MissingRefreshTokenException;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Token\Exception\ExpiredTokenException;
abstract class AbstractService extends BaseAbstractService implements ServiceInterface
{
/** @const OAUTH_VERSION */
const OAUTH_VERSION = 2;
/** @var array */
protected $scopes;
/** @var UriInterface|null */
protected $baseApiUri;
/** @var bool */
protected $stateParameterInAuthUrl;
/**
* @param CredentialsInterface $credentials
* @param ClientInterface $httpClient
* @param TokenStorageInterface $storage
* @param array $scopes
* @param UriInterface|null $baseApiUri
* @param bool $stateParameterInAutUrl
*
* @throws InvalidScopeException
*/
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null,
$stateParameterInAutUrl = false
) {
parent::__construct($credentials, $httpClient, $storage);
$this->stateParameterInAuthUrl = $stateParameterInAutUrl;
foreach ($scopes as $scope) {
if (!$this->isValidScope($scope)) {
throw new InvalidScopeException('Scope ' . $scope . ' is not valid for service ' . get_class($this));
}
}
$this->scopes = $scopes;
$this->baseApiUri = $baseApiUri;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'type' => 'web_server',
'client_id' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'response_type' => 'code',
)
);
$parameters['scope'] = implode(' ', $this->scopes);
if ($this->needsStateParameterInAuthUrl()) {
if (!isset($parameters['state'])) {
$parameters['state'] = $this->generateAuthorizationState();
}
$this->storeAuthorizationState($parameters['state']);
}
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritdoc}
*/
public function requestAccessToken($code, $state = null)
{
if (null !== $state) {
$this->validateAuthorizationState($state);
}
$bodyParams = array(
'code' => $code,
'client_id' => $this->credentials->getConsumerId(),
'client_secret' => $this->credentials->getConsumerSecret(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'grant_type' => 'authorization_code',
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$bodyParams,
$this->getExtraOAuthHeaders()
);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
/**
* Sends an authenticated API request to the path provided.
* If the path provided is not an absolute URI, the base API Uri (must be passed into constructor) will be used.
*
* @param string|UriInterface $path
* @param string $method HTTP method
* @param array $body Request body if applicable.
* @param array $extraHeaders Extra headers if applicable. These will override service-specific
* any defaults.
*
* @return string
*
* @throws ExpiredTokenException
* @throws Exception
*/
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array())
{
$uri = $this->determineRequestUriFromPath($path, $this->baseApiUri);
$token = $this->storage->retrieveAccessToken($this->service());
if ($token->getEndOfLife() !== TokenInterface::EOL_NEVER_EXPIRES
&& $token->getEndOfLife() !== TokenInterface::EOL_UNKNOWN
&& time() > $token->getEndOfLife()
) {
throw new ExpiredTokenException(
sprintf(
'Token expired on %s at %s',
date('m/d/Y', $token->getEndOfLife()),
date('h:i:s A', $token->getEndOfLife())
)
);
}
// add the token where it may be needed
if (static::AUTHORIZATION_METHOD_HEADER_OAUTH === $this->getAuthorizationMethod()) {
$extraHeaders = array_merge(array('Authorization' => 'OAuth ' . $token->getAccessToken()), $extraHeaders);
} elseif (static::AUTHORIZATION_METHOD_QUERY_STRING === $this->getAuthorizationMethod()) {
$uri->addToQuery('access_token', $token->getAccessToken());
} elseif (static::AUTHORIZATION_METHOD_QUERY_STRING_V2 === $this->getAuthorizationMethod()) {
$uri->addToQuery('oauth2_access_token', $token->getAccessToken());
} elseif (static::AUTHORIZATION_METHOD_QUERY_STRING_V3 === $this->getAuthorizationMethod()) {
$uri->addToQuery('apikey', $token->getAccessToken());
} elseif (static::AUTHORIZATION_METHOD_HEADER_BEARER === $this->getAuthorizationMethod()) {
$extraHeaders = array_merge(array('Authorization' => 'Bearer ' . $token->getAccessToken()), $extraHeaders);
}
$extraHeaders = array_merge($this->getExtraApiHeaders(), $extraHeaders);
return $this->httpClient->retrieveResponse($uri, $body, $extraHeaders, $method);
}
/**
* Accessor to the storage adapter to be able to retrieve tokens
*
* @return TokenStorageInterface
*/
public function getStorage()
{
return $this->storage;
}
/**
* Refreshes an OAuth2 access token.
*
* @param TokenInterface $token
*
* @return TokenInterface $token
*
* @throws MissingRefreshTokenException
*/
public function refreshAccessToken(TokenInterface $token)
{
$refreshToken = $token->getRefreshToken();
if (empty($refreshToken)) {
throw new MissingRefreshTokenException();
}
$parameters = array(
'grant_type' => 'refresh_token',
'type' => 'web_server',
'client_id' => $this->credentials->getConsumerId(),
'client_secret' => $this->credentials->getConsumerSecret(),
'refresh_token' => $refreshToken,
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$parameters,
$this->getExtraOAuthHeaders()
);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
/**
* Return whether or not the passed scope value is valid.
*
* @param string $scope
*
* @return bool
*/
public function isValidScope($scope)
{
$reflectionClass = new \ReflectionClass(get_class($this));
return in_array($scope, $reflectionClass->getConstants(), true);
}
/**
* Check if the given service need to generate a unique state token to build the authorization url
*
* @return bool
*/
public function needsStateParameterInAuthUrl()
{
return $this->stateParameterInAuthUrl;
}
/**
* Validates the authorization state against a given one
*
* @param string $state
* @throws InvalidAuthorizationStateException
*/
protected function validateAuthorizationState($state)
{
if ($this->retrieveAuthorizationState() !== $state) {
throw new InvalidAuthorizationStateException();
}
}
/**
* Generates a random string to be used as state
*
* @return string
*/
protected function generateAuthorizationState()
{
return md5(rand());
}
/**
* Retrieves the authorization state for the current service
*
* @return string
*/
protected function retrieveAuthorizationState()
{
return $this->storage->retrieveAuthorizationState($this->service());
}
/**
* Stores a given authorization state into the storage
*
* @param string $state
*/
protected function storeAuthorizationState($state)
{
$this->storage->storeAuthorizationState($this->service(), $state);
}
/**
* Return any additional headers always needed for this service implementation's OAuth calls.
*
* @return array
*/
protected function getExtraOAuthHeaders()
{
return array();
}
/**
* Return any additional headers always needed for this service implementation's API calls.
*
* @return array
*/
protected function getExtraApiHeaders()
{
return array();
}
/**
* Parses the access token response and returns a TokenInterface.
*
* @abstract
*
* @param string $responseBody
*
* @return TokenInterface
*
* @throws TokenResponseException
*/
abstract protected function parseAccessTokenResponse($responseBody);
/**
* Returns a class constant from ServiceInterface defining the authorization method used for the API
* Header is the sane default.
*
* @return int
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_OAUTH;
}
}

97
vendor/OAuth/OAuth2/Service/Amazon.php vendored
View File

@@ -1,97 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Amazon service.
*
* @author Flávio Heleno <flaviohbatista@gmail.com>
* @link https://images-na.ssl-images-amazon.com/images/G/01/lwa/dev/docs/website-developer-guide._TTH_.pdf
*/
class Amazon extends AbstractService
{
/**
* Defined scopes
* @link https://images-na.ssl-images-amazon.com/images/G/01/lwa/dev/docs/website-developer-guide._TTH_.pdf
*/
const SCOPE_PROFILE = 'profile';
const SCOPE_POSTAL_CODE = 'postal_code';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.amazon.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.amazon.com/ap/oa');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.amazon.com/ap/oatoken');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error_description'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error_description'] . '"');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

111
vendor/OAuth/OAuth2/Service/Bitly.php vendored
View File

@@ -1,111 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Bitly extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api-ssl.bitly.com/v3/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://bitly.com/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api-ssl.bitly.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
// I'm invincible!!!
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
public function requestAccessToken($code, $state = null)
{
if (null !== $state) {
$this->validateAuthorizationState($state);
}
$bodyParams = array(
'code' => $code,
'client_id' => $this->credentials->getConsumerId(),
'client_secret' => $this->credentials->getConsumerSecret(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'grant_type' => 'authorization_code',
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$bodyParams,
$this->getExtraOAuthHeaders()
);
// we can scream what we want that we want bitly to return a json encoded string (format=json), but the
// WOAH WATCH YOUR LANGUAGE ;) service doesn't seem to like screaming, hence we need to manually
// parse the result
$parsedResult = array();
parse_str($responseBody, $parsedResult);
$token = $this->parseAccessTokenResponse(json_encode($parsedResult));
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
}

88
vendor/OAuth/OAuth2/Service/Box.php vendored
View File

@@ -1,88 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Box service.
*
* @author Antoine Corcy <contact@sbin.dk>
* @link https://developers.box.com/oauth/
*/
class Box extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri, true);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.box.com/2.0/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.box.com/api/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.box.com/api/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

151
vendor/OAuth/OAuth2/Service/Buffer.php vendored
View File

@@ -1,151 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
/**
* Buffer API.
* @author Sumukh Sridhara <@sumukhsridhara>
* @link https://bufferapp.com/developers/api
*/
class Buffer extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if ($baseApiUri === null) {
$this->baseApiUri = new Uri('https://api.bufferapp.com/1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://bufferapp.com/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.bufferapp.com/1/oauth2/token.json');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'client_id' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'response_type' => 'code',
)
);
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritdoc}
*/
public function requestRequestToken()
{
$responseBody = $this->httpClient->retrieveResponse(
$this->getRequestTokenEndpoint(),
array(
'client_key' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'response_type' => 'code',
)
);
$code = $this->parseRequestTokenResponse($responseBody);
return $code;
}
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['code'])) {
throw new TokenResponseException('Error in retrieving code.');
}
return $data['code'];
}
public function requestAccessToken($code)
{
$bodyParams = array(
'client_id' => $this->credentials->getConsumerId(),
'client_secret' => $this->credentials->getConsumerSecret(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'code' => $code,
'grant_type' => 'authorization_code',
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$bodyParams,
$this->getExtraOAuthHeaders()
);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if ($data === null || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

129
vendor/OAuth/OAuth2/Service/Dailymotion.php vendored
View File

@@ -1,129 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Dailymotion service.
*
* @author Mouhamed SEYE <mouhamed@seye.pro>
* @link http://www.dailymotion.com/doc/api/authentication.html
*/
class Dailymotion extends AbstractService
{
/**
* Scopes
*
* @var string
*/
const SCOPE_EMAIL = 'email',
SCOPE_PROFILE = 'userinfo',
SCOPE_VIDEOS = 'manage_videos',
SCOPE_COMMENTS = 'manage_comments',
SCOPE_PLAYLIST = 'manage_playlists',
SCOPE_TILES = 'manage_tiles',
SCOPE_SUBSCRIPTIONS = 'manage_subscriptions',
SCOPE_FRIENDS = 'manage_friends',
SCOPE_FAVORITES = 'manage_favorites',
SCOPE_GROUPS = 'manage_groups';
/**
* Dialog form factors
*
* @var string
*/
const DISPLAY_PAGE = 'page',
DISPLAY_POPUP = 'popup',
DISPLAY_MOBILE = 'mobile';
/**
* {@inheritdoc}
*/
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.dailymotion.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://api.dailymotion.com/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.dailymotion.com/oauth/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_OAUTH;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error_description']) || isset($data['error'])) {
throw new TokenResponseException(
sprintf(
'Error in retrieving token: "%s"',
isset($data['error_description']) ? $data['error_description'] : $data['error']
)
);
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getExtraOAuthHeaders()
{
return array('Accept' => 'application/json');
}
}

111
vendor/OAuth/OAuth2/Service/Dropbox.php vendored
View File

@@ -1,111 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Dropbox service.
*
* @author Flávio Heleno <flaviohbatista@gmail.com>
* @link https://www.dropbox.com/developers/core/docs
*/
class Dropbox extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.dropbox.com/1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'client_id' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'response_type' => 'code',
)
);
$parameters['scope'] = implode(' ', $this->scopes);
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.dropbox.com/1/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.dropbox.com/1/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

12
vendor/OAuth/OAuth2/Service/Exception/InvalidAccessTypeException.php vendored
View File

@@ -1,12 +0,0 @@
<?php
namespace OAuth\OAuth2\Service\Exception;
use OAuth\Common\Exception\Exception;
/**
* Exception thrown when an invalid accessType for the Google Service is specified
*/
class InvalidAccessTypeException extends Exception
{
}

10
vendor/OAuth/OAuth2/Service/Exception/InvalidAuthorizationStateException.php vendored
View File

@@ -1,10 +0,0 @@
<?php
namespace OAuth\OAuth2\Service\Exception;
/**
* Exception thrown when the state parameter received during the authorization process is invalid.
*/
class InvalidAuthorizationStateException extends \Exception
{
}

17
vendor/OAuth/OAuth2/Service/Exception/InvalidScopeException.php vendored
View File

@@ -1,17 +0,0 @@
<?php
/**
* @author David Desberg <david@daviddesberg.com>
* Released under the MIT license.
*/
namespace OAuth\OAuth2\Service\Exception;
use OAuth\Common\Exception\Exception;
/**
* Exception thrown when a scope provided to a service is invalid.
*/
class InvalidScopeException extends Exception
{
}

17
vendor/OAuth/OAuth2/Service/Exception/MissingRefreshTokenException.php vendored
View File

@@ -1,17 +0,0 @@
<?php
/**
* @author David Desberg <david@daviddesberg.com>
* Released under the MIT license.
*/
namespace OAuth\OAuth2\Service\Exception;
use OAuth\Common\Exception\Exception;
/**
* Exception thrown when service is requested to refresh the access token but no refresh token can be found.
*/
class MissingRefreshTokenException extends Exception
{
}

193
vendor/OAuth/OAuth2/Service/Facebook.php vendored
View File

@@ -1,193 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\Common\Exception\Exception;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Facebook extends AbstractService
{
/**
* Facebook www url - used to build dialog urls
*/
const WWW_URL = 'https://www.facebook.com/';
/**
* Defined scopes
*
* If you don't think this is scary you should not be allowed on the web at all
*
* @link https://developers.facebook.com/docs/reference/login/
* @link https://developers.facebook.com/tools/explorer For a list of permissions use 'Get Access Token'
*/
// email scopes
const SCOPE_EMAIL = 'email';
// extended permissions
const SCOPE_READ_FRIENDLIST = 'read_friendlists';
const SCOPE_READ_INSIGHTS = 'read_insights';
const SCOPE_READ_MAILBOX = 'read_mailbox';
const SCOPE_READ_PAGE_MAILBOXES = 'read_page_mailboxes';
const SCOPE_READ_REQUESTS = 'read_requests';
const SCOPE_READ_STREAM = 'read_stream';
const SCOPE_VIDEO_UPLOAD = 'video_upload';
const SCOPE_XMPP_LOGIN = 'xmpp_login';
const SCOPE_USER_ONLINE_PRESENCE = 'user_online_presence';
const SCOPE_FRIENDS_ONLINE_PRESENCE = 'friends_online_presence';
const SCOPE_ADS_MANAGEMENT = 'ads_management';
const SCOPE_ADS_READ = 'ads_read';
const SCOPE_CREATE_EVENT = 'create_event';
const SCOPE_CREATE_NOTE = 'create_note';
const SCOPE_EXPORT_STREAM = 'export_stream';
const SCOPE_MANAGE_FRIENDLIST = 'manage_friendlists';
const SCOPE_MANAGE_NOTIFICATIONS = 'manage_notifications';
const SCOPE_PHOTO_UPLOAD = 'photo_upload';
const SCOPE_PUBLISH_ACTIONS = 'publish_actions';
const SCOPE_PUBLISH_CHECKINS = 'publish_checkins';
const SCOPE_PUBLISH_STREAM = 'publish_stream';
const SCOPE_RSVP_EVENT = 'rsvp_event';
const SCOPE_SHARE_ITEM = 'share_item';
const SCOPE_SMS = 'sms';
const SCOPE_STATUS_UPDATE = 'status_update';
// Extended Profile Properties
const SCOPE_USER_FRIENDS = 'user_friends';
const SCOPE_USER_ABOUT = 'user_about_me';
const SCOPE_FRIENDS_ABOUT = 'friends_about_me';
const SCOPE_USER_ACTIVITIES = 'user_activities';
const SCOPE_FRIENDS_ACTIVITIES = 'friends_activities';
const SCOPE_USER_BIRTHDAY = 'user_birthday';
const SCOPE_FRIENDS_BIRTHDAY = 'friends_birthday';
const SCOPE_USER_CHECKINS = 'user_checkins';
const SCOPE_FRIENDS_CHECKINS = 'friends_checkins';
const SCOPE_USER_EDUCATION = 'user_education_history';
const SCOPE_FRIENDS_EDUCATION = 'friends_education_history';
const SCOPE_USER_EVENTS = 'user_events';
const SCOPE_FRIENDS_EVENTS = 'friends_events';
const SCOPE_USER_GROUPS = 'user_groups';
const SCOPE_FRIENDS_GROUPS = 'friends_groups';
const SCOPE_USER_HOMETOWN = 'user_hometown';
const SCOPE_FRIENDS_HOMETOWN = 'friends_hometown';
const SCOPE_USER_INTERESTS = 'user_interests';
const SCOPE_FRIEND_INTERESTS = 'friends_interests';
const SCOPE_USER_LIKES = 'user_likes';
const SCOPE_FRIENDS_LIKES = 'friends_likes';
const SCOPE_USER_LOCATION = 'user_location';
const SCOPE_FRIENDS_LOCATION = 'friends_location';
const SCOPE_USER_NOTES = 'user_notes';
const SCOPE_FRIENDS_NOTES = 'friends_notes';
const SCOPE_USER_PHOTOS = 'user_photos';
const SCOPE_USER_PHOTO_VIDEO_TAGS = 'user_photo_video_tags';
const SCOPE_FRIENDS_PHOTOS = 'friends_photos';
const SCOPE_FRIENDS_PHOTO_VIDEO_TAGS = 'friends_photo_video_tags';
const SCOPE_USER_QUESTIONS = 'user_questions';
const SCOPE_FRIENDS_QUESTIONS = 'friends_questions';
const SCOPE_USER_RELATIONSHIPS = 'user_relationships';
const SCOPE_FRIENDS_RELATIONSHIPS = 'friends_relationships';
const SCOPE_USER_RELATIONSHIPS_DETAILS = 'user_relationship_details';
const SCOPE_FRIENDS_RELATIONSHIPS_DETAILS = 'friends_relationship_details';
const SCOPE_USER_RELIGION = 'user_religion_politics';
const SCOPE_FRIENDS_RELIGION = 'friends_religion_politics';
const SCOPE_USER_STATUS = 'user_status';
const SCOPE_FRIENDS_STATUS = 'friends_status';
const SCOPE_USER_SUBSCRIPTIONS = 'user_subscriptions';
const SCOPE_FRIENDS_SUBSCRIPTIONS = 'friends_subscriptions';
const SCOPE_USER_VIDEOS = 'user_videos';
const SCOPE_FRIENDS_VIDEOS = 'friends_videos';
const SCOPE_USER_WEBSITE = 'user_website';
const SCOPE_FRIENDS_WEBSITE = 'friends_website';
const SCOPE_USER_WORK = 'user_work_history';
const SCOPE_FRIENDS_WORK = 'friends_work_history';
// Open Graph Permissions
const SCOPE_USER_MUSIC = 'user_actions.music';
const SCOPE_FRIENDS_MUSIC = 'friends_actions.music';
const SCOPE_USER_NEWS = 'user_actions.news';
const SCOPE_FRIENDS_NEWS = 'friends_actions.news';
const SCOPE_USER_VIDEO = 'user_actions.video';
const SCOPE_FRIENDS_VIDEO = 'friends_actions.video';
const SCOPE_USER_APP = 'user_actions:APP_NAMESPACE';
const SCOPE_FRIENDS_APP = 'friends_actions:APP_NAMESPACE';
const SCOPE_USER_GAMES = 'user_games_activity';
const SCOPE_FRIENDS_GAMES = 'friends_games_activity';
//Page Permissions
const SCOPE_PAGES = 'manage_pages';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://graph.facebook.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.facebook.com/dialog/oauth');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://graph.facebook.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
// Facebook gives us a query string ... Oh wait. JSON is too simple, understand ?
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
if (isset($data['expires'])) {
$token->setLifeTime($data['expires']);
}
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires']);
$token->setExtraParams($data);
return $token;
}
public function getDialogUri($dialogPath, array $parameters)
{
if (!isset($parameters['redirect_uri'])) {
throw new Exception("Redirect uri is mandatory for this request");
}
$parameters['app_id'] = $this->credentials->getConsumerId();
$baseUrl = self::WWW_URL . 'dialog/' . $dialogPath;
$query = http_build_query($parameters);
return new Uri($baseUrl . '?' . $query);
}
}

81
vendor/OAuth/OAuth2/Service/Foursquare.php vendored
View File

@@ -1,81 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Foursquare extends AbstractService
{
private $apiVersionDate = '20130829';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.foursquare.com/v2/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://foursquare.com/oauth2/authenticate');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://foursquare.com/oauth2/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
// Foursquare tokens evidently never expire...
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array())
{
$uri = new Uri($this->baseApiUri . $path);
$uri->addToQuery('v', $this->apiVersionDate);
return parent::request($uri, $method, $body, $extraHeaders);
}
}

208
vendor/OAuth/OAuth2/Service/GitHub.php vendored
View File

@@ -1,208 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class GitHub extends AbstractService
{
/**
* Defined scopes, see http://developer.github.com/v3/oauth/ for definitions.
*/
/**
* Public read-only access (includes public user profile info, public repo info, and gists)
*/
const SCOPE_READONLY = '';
/**
* Read/write access to profile info only.
*
* Includes SCOPE_USER_EMAIL and SCOPE_USER_FOLLOW.
*/
const SCOPE_USER = 'user';
/**
* Read access to a user’s email addresses.
*/
const SCOPE_USER_EMAIL = 'user:email';
/**
* Access to follow or unfollow other users.
*/
const SCOPE_USER_FOLLOW = 'user:follow';
/**
* Read/write access to public repos and organizations.
*/
const SCOPE_PUBLIC_REPO = 'public_repo';
/**
* Read/write access to public and private repos and organizations.
*
* Includes SCOPE_REPO_STATUS.
*/
const SCOPE_REPO = 'repo';
/**
* Grants access to deployment statuses for public and private repositories.
* This scope is only necessary to grant other users or services access to deployment statuses,
* without granting access to the code.
*/
const SCOPE_REPO_DEPLOYMENT = 'repo_deployment';
/**
* Read/write access to public and private repository commit statuses. This scope is only necessary to grant other
* users or services access to private repository commit statuses without granting access to the code. The repo and
* public_repo scopes already include access to commit status for private and public repositories, respectively.
*/
const SCOPE_REPO_STATUS = 'repo:status';
/**
* Delete access to adminable repositories.
*/
const SCOPE_DELETE_REPO = 'delete_repo';
/**
* Read access to a user’s notifications. repo is accepted too.
*/
const SCOPE_NOTIFICATIONS = 'notifications';
/**
* Write access to gists.
*/
const SCOPE_GIST = 'gist';
/**
* Grants read and ping access to hooks in public or private repositories.
*/
const SCOPE_HOOKS_READ = 'read:repo_hook';
/**
* Grants read, write, and ping access to hooks in public or private repositories.
*/
const SCOPE_HOOKS_WRITE = 'write:repo_hook';
/**
* Grants read, write, ping, and delete access to hooks in public or private repositories.
*/
const SCOPE_HOOKS_ADMIN = 'admin:repo_hook';
/**
* Read-only access to organization, teams, and membership.
*/
const SCOPE_ORG_READ = 'read:org';
/**
* Publicize and unpublicize organization membership.
*/
const SCOPE_ORG_WRITE = 'write:org';
/**
* Fully manage organization, teams, and memberships.
*/
const SCOPE_ORG_ADMIN = 'admin:org';
/**
* List and view details for public keys.
*/
const SCOPE_PUBLIC_KEY_READ = 'read:public_key';
/**
* Create, list, and view details for public keys.
*/
const SCOPE_PUBLIC_KEY_WRITE = 'write:public_key';
/**
* Fully manage public keys.
*/
const SCOPE_PUBLIC_KEY_ADMIN = 'admin:public_key';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.github.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://github.com/login/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://github.com/login/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
// Github tokens evidently never expire...
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
/**
* Used to configure response type -- we want JSON from github, default is query string format
*
* @return array
*/
protected function getExtraOAuthHeaders()
{
return array('Accept' => 'application/json');
}
/**
* Required for GitHub API calls.
*
* @return array
*/
protected function getExtraApiHeaders()
{
return array('Accept' => 'application/vnd.github.beta+json');
}
}

158
vendor/OAuth/OAuth2/Service/Google.php vendored
View File

@@ -1,158 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\OAuth2\Service\Exception\InvalidAccessTypeException;
use OAuth\Common\Http\Uri\Uri;
class Google extends AbstractService
{
/**
* Defined scopes - More scopes are listed here:
* https://developers.google.com/oauthplayground/
*
* Make a pull request if you need more scopes.
*/
// Basic
const SCOPE_EMAIL = 'email';
const SCOPE_PROFILE = 'profile';
const SCOPE_USERINFO_EMAIL = 'https://www.googleapis.com/auth/userinfo.email';
const SCOPE_USERINFO_PROFILE = 'https://www.googleapis.com/auth/userinfo.profile';
// Google+
const SCOPE_GPLUS_ME = 'https://www.googleapis.com/auth/plus.me';
const SCOPE_GPLUS_LOGIN = 'https://www.googleapis.com/auth/plus.login';
const SCOPE_GPLUS_CIRCLES_READ = 'https://www.googleapis.com/auth/plus.circles.read';
const SCOPE_GPLUS_CIRCLES_WRITE = 'https://www.googleapis.com/auth/plus.circles.write';
const SCOPE_GPLUS_STREAM_READ = 'https://www.googleapis.com/auth/plus.stream.read';
const SCOPE_GPLUS_STREAM_WRITE = 'https://www.googleapis.com/auth/plus.stream.write';
const SCOPE_GPLUS_MEDIA = 'https://www.googleapis.com/auth/plus.media.upload';
// Google Drive
const SCOPE_DOCUMENTSLIST = 'https://docs.google.com/feeds/';
const SCOPE_SPREADSHEETS = 'https://spreadsheets.google.com/feeds/';
const SCOPE_GOOGLEDRIVE = 'https://www.googleapis.com/auth/drive';
const SCOPE_DRIVE_APPS = 'https://www.googleapis.com/auth/drive.appdata';
const SCOPE_DRIVE_APPS_READ_ONLY = 'https://www.googleapis.com/auth/drive.apps.readonly';
const SCOPE_GOOGLEDRIVE_FILES = 'https://www.googleapis.com/auth/drive.file';
const SCOPE_DRIVE_METADATA_READ_ONLY = 'https://www.googleapis.com/auth/drive.metadata.readonly';
const SCOPE_DRIVE_READ_ONLY = 'https://www.googleapis.com/auth/drive.readonly';
const SCOPE_DRIVE_SCRIPTS = 'https://www.googleapis.com/auth/drive.scripts';
// Adwords
const SCOPE_ADSENSE = 'https://www.googleapis.com/auth/adsense';
const SCOPE_ADWORDS = 'https://adwords.google.com/api/adwords/';
const SCOPE_GAN = 'https://www.googleapis.com/auth/gan'; // google affiliate network...?
// Google Analytics
const SCOPE_ANALYTICS = 'https://www.googleapis.com/auth/analytics';
const SCOPE_ANALYTICS_EDIT = 'https://www.googleapis.com/auth/analytics.edit';
const SCOPE_ANALYTICS_MANAGE_USERS = 'https://www.googleapis.com/auth/analytics.manage.users';
const SCOPE_ANALYTICS_READ_ONLY = 'https://www.googleapis.com/auth/analytics.readonly';
// Other services
const SCOPE_BOOKS = 'https://www.googleapis.com/auth/books';
const SCOPE_BLOGGER = 'https://www.googleapis.com/auth/blogger';
const SCOPE_CALENDAR = 'https://www.googleapis.com/auth/calendar';
const SCOPE_CALENDAR_READ_ONLY = 'https://www.googleapis.com/auth/calendar.readonly';
const SCOPE_CONTACT = 'https://www.google.com/m8/feeds/';
const SCOPE_CHROMEWEBSTORE = 'https://www.googleapis.com/auth/chromewebstore.readonly';
const SCOPE_GMAIL = 'https://mail.google.com/mail/feed/atom';
const SCOPE_GMAIL_IMAP_SMTP = 'https://mail.google.com';
const SCOPE_PICASAWEB = 'https://picasaweb.google.com/data/';
const SCOPE_SITES = 'https://sites.google.com/feeds/';
const SCOPE_URLSHORTENER = 'https://www.googleapis.com/auth/urlshortener';
const SCOPE_WEBMASTERTOOLS = 'https://www.google.com/webmasters/tools/feeds/';
const SCOPE_TASKS = 'https://www.googleapis.com/auth/tasks';
// Cloud services
const SCOPE_CLOUDSTORAGE = 'https://www.googleapis.com/auth/devstorage.read_write';
const SCOPE_CONTENTFORSHOPPING = 'https://www.googleapis.com/auth/structuredcontent'; // what even is this
const SCOPE_USER_PROVISIONING = 'https://apps-apis.google.com/a/feeds/user/';
const SCOPE_GROUPS_PROVISIONING = 'https://apps-apis.google.com/a/feeds/groups/';
const SCOPE_NICKNAME_PROVISIONING = 'https://apps-apis.google.com/a/feeds/alias/';
// Old
const SCOPE_ORKUT = 'https://www.googleapis.com/auth/orkut';
const SCOPE_GOOGLELATITUDE =
'https://www.googleapis.com/auth/latitude.all.best https://www.googleapis.com/auth/latitude.all.city';
const SCOPE_OPENID = 'openid';
// YouTube
const SCOPE_YOUTUBE_GDATA = 'https://gdata.youtube.com';
const SCOPE_YOUTUBE_ANALYTICS_MONETARY = 'https://www.googleapis.com/auth/yt-analytics-monetary.readonly';
const SCOPE_YOUTUBE_ANALYTICS = 'https://www.googleapis.com/auth/yt-analytics.readonly';
const SCOPE_YOUTUBE = 'https://www.googleapis.com/auth/youtube';
const SCOPE_YOUTUBE_READ_ONLY = 'https://www.googleapis.com/auth/youtube.readonly';
const SCOPE_YOUTUBE_UPLOAD = 'https://www.googleapis.com/auth/youtube.upload';
const SCOPE_YOUTUBE_PARTNER = 'https://www.googleapis.com/auth/youtubepartner';
const SCOPE_YOUTUBE_PARTNER_AUDIT = 'https://www.googleapis.com/auth/youtubepartner-channel-audit';
// Google Glass
const SCOPE_GLASS_TIMELINE = 'https://www.googleapis.com/auth/glass.timeline';
const SCOPE_GLASS_LOCATION = 'https://www.googleapis.com/auth/glass.location';
// Android Publisher
const SCOPE_ANDROID_PUBLISHER = 'https://www.googleapis.com/auth/androidpublisher';
protected $accessType = 'online';
public function setAccessType($accessType)
{
if (!in_array($accessType, array('online', 'offline'), true)) {
throw new InvalidAccessTypeException('Invalid accessType, expected either online or offline');
}
$this->accessType = $accessType;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://accounts.google.com/o/oauth2/auth?access_type=' . $this->accessType);
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://accounts.google.com/o/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifetime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

157
vendor/OAuth/OAuth2/Service/Harvest.php vendored
View File

@@ -1,157 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Token\TokenInterface;
use OAuth\OAuth2\Token\StdOAuth2Token;
class Harvest extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.harvestapp.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'client_id' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'state' => 'optional-csrf-token',
'response_type' => 'code',
)
);
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://api.harvestapp.com/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.harvestapp.com/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || ! is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifetime($data['expires_in']);
$token->setRefreshToken($data['refresh_token']);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
/**
* Refreshes an OAuth2 access token.
*
* @param TokenInterface $token
*
* @return TokenInterface $token
*
* @throws MissingRefreshTokenException
*/
public function refreshAccessToken(TokenInterface $token)
{
$refreshToken = $token->getRefreshToken();
if (empty($refreshToken)) {
throw new MissingRefreshTokenException();
}
$parameters = array(
'grant_type' => 'refresh_token',
'type' => 'web_server',
'client_id' => $this->credentials->getConsumerId(),
'client_secret' => $this->credentials->getConsumerSecret(),
'refresh_token' => $refreshToken,
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$parameters,
$this->getExtraOAuthHeaders()
);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
/**
* @return array
*/
protected function getExtraOAuthHeaders()
{
return array('Accept' => 'application/json');
}
/**
* Return any additional headers always needed for this service implementation's API calls.
*
* @return array
*/
protected function getExtraApiHeaders()
{
return array('Accept' => 'application/json');
}
}

123
vendor/OAuth/OAuth2/Service/Heroku.php vendored
View File

@@ -1,123 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Heroku service.
*
* @author Thomas Welton <thomaswelton@me.com>
* @link https://devcenter.heroku.com/articles/oauth
*/
class Heroku extends AbstractService
{
/**
* Defined scopes
* @link https://devcenter.heroku.com/articles/oauth#scopes
*/
const SCOPE_GLOBAL = 'global';
const SCOPE_IDENTITY = 'identity';
const SCOPE_READ = 'read';
const SCOPE_WRITE = 'write';
const SCOPE_READ_PROTECTED = 'read-protected';
const SCOPE_WRITE_PROTECTED = 'write-protected';
/**
* {@inheritdoc}
*/
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.heroku.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://id.heroku.com/oauth/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://id.heroku.com/oauth/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error_description']) || isset($data['error'])) {
throw new TokenResponseException(
sprintf(
'Error in retrieving token: "%s"',
isset($data['error_description']) ? $data['error_description'] : $data['error']
)
);
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getExtraOAuthHeaders()
{
return array('Accept' => 'application/vnd.heroku+json; version=3');
}
/**
* {@inheritdoc}
*/
protected function getExtraApiHeaders()
{
return array('Accept' => 'application/vnd.heroku+json; version=3', 'Content-Type' => 'application/json');
}
}

85
vendor/OAuth/OAuth2/Service/Instagram.php vendored
View File

@@ -1,85 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Instagram extends AbstractService
{
/**
* Defined scopes
* @link http://instagram.com/developer/authentication/#scope
*/
const SCOPE_BASIC = 'basic';
const SCOPE_COMMENTS = 'comments';
const SCOPE_RELATIONSHIPS = 'relationships';
const SCOPE_LIKES = 'likes';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.instagram.com/v1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://api.instagram.com/oauth/authorize/');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.instagram.com/oauth/access_token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
// Instagram tokens evidently never expire...
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

102
vendor/OAuth/OAuth2/Service/Linkedin.php vendored
View File

@@ -1,102 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Linkedin service.
*
* @author Antoine Corcy <contact@sbin.dk>
* @link http://developer.linkedin.com/documents/authentication
*/
class Linkedin extends AbstractService
{
/**
* Defined scopes
* @link http://developer.linkedin.com/documents/authentication#granting
*/
const SCOPE_R_BASICPROFILE = 'r_basicprofile';
const SCOPE_R_FULLPROFILE = 'r_fullprofile';
const SCOPE_R_EMAILADDRESS = 'r_emailaddress';
const SCOPE_R_NETWORK = 'r_network';
const SCOPE_R_CONTACTINFO = 'r_contactinfo';
const SCOPE_RW_NUS = 'rw_nus';
const SCOPE_RW_COMPANY_ADMIN = 'rw_company_admin';
const SCOPE_RW_GROUPS = 'rw_groups';
const SCOPE_W_MESSAGES = 'w_messages';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri, true);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.linkedin.com/v1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.linkedin.com/uas/oauth2/authorization');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.linkedin.com/uas/oauth2/accessToken');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING_V2;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

115
vendor/OAuth/OAuth2/Service/Mailchimp.php vendored
View File

@@ -1,115 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Mailchimp extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (is_null($this->baseApiUri) && $storage->hasAccessToken($this->service())) {
$this->setBaseApiUri($storage->retrieveAccessToken($this->service()));
}
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING_V3;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://login.mailchimp.com/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://login.mailchimp.com/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
// Parse JSON
$data = json_decode($responseBody, true);
// Do validation.
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
// Create token object.
$token = new StdOAuth2Token($data['access_token']);
// Set the right API endpoint.
$this->setBaseApiUri($token);
// Mailchimp tokens evidently never expire...
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
return $token;
}
/**
* {@inheritdoc}
*/
public function request($path, $method = 'GET', $body = null, array $extraHeaders = array())
{
if (is_null($this->baseApiUri)) {
$this->setBaseApiUri($this->storage->retrieveAccessToken($this->service()));
}
return parent::request($path, $method, $body, $extraHeaders);
}
/**
* Set the right base endpoint.
*
* @param StdOAuth2Token $token
*/
protected function setBaseApiUri(StdOAuth2Token $token)
{
// Make request uri.
$endpoint = 'https://login.mailchimp.com/oauth2/metadata?oauth_token='. $token->getAccessToken();
// Grab meta data about the token.
$response = $this->httpClient->retrieveResponse(new Uri($endpoint), array(), array(), 'GET');
// Parse JSON.
$meta = json_decode($response, true);
// Set base api uri.
$this->baseApiUri = new Uri('https://'. $meta['dc'] .'.api.mailchimp.com/2.0/');
// Allow chaining.
return $this;
}
}

119
vendor/OAuth/OAuth2/Service/Microsoft.php vendored
View File

@@ -1,119 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Microsoft extends AbstractService
{
const SCOPE_BASIC = 'wl.basic';
const SCOPE_OFFLINE = 'wl.offline_access';
const SCOPE_SIGNIN = 'wl.signin';
const SCOPE_BIRTHDAY = 'wl.birthday';
const SCOPE_CALENDARS = 'wl.calendars';
const SCOPE_CALENDARS_UPDATE = 'wl.calendars_update';
const SCOPE_CONTACTS_BIRTHDAY = 'wl.contacts_birthday';
const SCOPE_CONTACTS_CREATE = 'wl.contacts_create';
const SCOPE_CONTACTS_CALENDARS = 'wl.contacts_calendars';
const SCOPE_CONTACTS_PHOTOS = 'wl.contacts_photos';
const SCOPE_CONTACTS_SKYDRIVE = 'wl.contacts_skydrive';
const SCOPE_EMAILS = 'wl.emails';
const SCOPE_EVENTS_CREATE = 'wl.events_create';
const SCOPE_MESSENGER = 'wl.messenger';
const SCOPE_PHONE_NUMBERS = 'wl.phone_numbers';
const SCOPE_PHOTOS = 'wl.photos';
const SCOPE_POSTAL_ADDRESSES = 'wl.postal_addresses';
const SCOPE_SHARE = 'wl.share';
const SCOPE_SKYDRIVE = 'wl.skydrive';
const SCOPE_SKYDRIVE_UPDATE = 'wl.skydrive_update';
const SCOPE_WORK_PROFILE = 'wl.work_profile';
const SCOPE_APPLICATIONS = 'wl.applications';
const SCOPE_APPLICATIONS_CREATE = 'wl.applications_create';
/**
* MS uses some magical not officialy supported scope to get even moar info like full emailaddresses.
* They agree that giving 3rd party apps access to 3rd party emailaddresses is a pretty lame thing to do so in all
* their wisdom they added this scope because fuck you that's why.
*
* https://github.com/Lusitanian/PHPoAuthLib/issues/214
* http://social.msdn.microsoft.com/Forums/live/en-US/c6dcb9ab-aed4-400a-99fb-5650c393a95d/how-retrieve-users-
* contacts-email-address?forum=messengerconnect
*
* Considering this scope is not officially supported: use with care
*/
const SCOPE_CONTACTS_EMAILS = 'wl.contacts_emails';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://apis.live.net/v5.0/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://login.live.com/oauth20_authorize.srf');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://login.live.com/oauth20_token.srf');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifetime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

103
vendor/OAuth/OAuth2/Service/Paypal.php vendored
View File

@@ -1,103 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* PayPal service.
*
* @author Flávio Heleno <flaviohbatista@gmail.com>
* @link https://developer.paypal.com/webapps/developer/docs/integration/direct/log-in-with-paypal/detailed/
*/
class Paypal extends AbstractService
{
/**
* Defined scopes
* @link https://developer.paypal.com/webapps/developer/docs/integration/direct/log-in-with-paypal/detailed/
* @see #attributes
*/
const SCOPE_OPENID = 'openid';
const SCOPE_PROFILE = 'profile';
const SCOPE_PAYPALATTRIBUTES = 'https://uri.paypal.com/services/paypalattributes';
const SCOPE_EMAIL = 'email';
const SCOPE_ADDRESS = 'address';
const SCOPE_PHONE = 'phone';
const SCOPE_EXPRESSCHECKOUT = 'https://uri.paypal.com/services/expresscheckout';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.paypal.com/v1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.paypal.com/webapps/auth/protocol/openidconnect/v1/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.paypal.com/v1/identity/openidconnect/tokenservice');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['message'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['message'] . '"');
} elseif (isset($data['name'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['name'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

125
vendor/OAuth/OAuth2/Service/Pocket.php vendored
View File

@@ -1,125 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
class Pocket extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if ($baseApiUri === null) {
$this->baseApiUri = new Uri('https://getpocket.com/v3/');
}
}
public function getRequestTokenEndpoint()
{
return new Uri('https://getpocket.com/v3/oauth/request');
}
public function getAuthorizationEndpoint()
{
return new Uri('https://getpocket.com/auth/authorize');
}
public function getAccessTokenEndpoint()
{
return new Uri('https://getpocket.com/v3/oauth/authorize');
}
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'redirect_uri' => $this->credentials->getCallbackUrl(),
)
);
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
public function requestRequestToken()
{
$responseBody = $this->httpClient->retrieveResponse(
$this->getRequestTokenEndpoint(),
array(
'consumer_key' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
)
);
$code = $this->parseRequestTokenResponse($responseBody);
return $code;
}
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['code'])) {
throw new TokenResponseException('Error in retrieving code.');
}
return $data['code'];
}
public function requestAccessToken($code)
{
$bodyParams = array(
'consumer_key' => $this->credentials->getConsumerId(),
'code' => $code,
);
$responseBody = $this->httpClient->retrieveResponse(
$this->getAccessTokenEndpoint(),
$bodyParams,
$this->getExtraOAuthHeaders()
);
$token = $this->parseAccessTokenResponse($responseBody);
$this->storage->storeAccessToken($this->service(), $token);
return $token;
}
protected function parseAccessTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if ($data === null || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
#$token->setRequestToken($data['access_token']);
$token->setAccessToken($data['access_token']);
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

114
vendor/OAuth/OAuth2/Service/Reddit.php vendored
View File

@@ -1,114 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Reddit extends AbstractService
{
/**
* Defined scopes
*
* @link http://www.reddit.com/dev/api/oauth
*/
// User scopes
const SCOPE_EDIT = 'edit';
const SCOPE_HISTORY = 'history';
const SCOPE_IDENTITY = 'identity';
const SCOPE_MYSUBREDDITS = 'mysubreddits';
const SCOPE_PRIVATEMESSAGES = 'privatemessages';
const SCOPE_READ = 'read';
const SCOPE_SAVE = 'save';
const SCOPE_SUBMIT = 'submit';
const SCOPE_SUBSCRIBE = 'subscribe';
const SCOPE_VOTE = 'vote';
// Mod Scopes
const SCOPE_MODCONFIG = 'modconfig';
const SCOPE_MODFLAIR = 'modflair';
const SCOPE_MODLOG = 'modlog';
const SCOPE_MODPOST = 'modpost';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri, true);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://oauth.reddit.com');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://ssl.reddit.com/api/v1/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://ssl.reddit.com/api/v1/access_token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getExtraOAuthHeaders()
{
// Reddit uses a Basic OAuth header
return array('Authorization' => 'Basic ' .
base64_encode($this->credentials->getConsumerId() . ':' . $this->credentials->getConsumerSecret()));
}
}

105
vendor/OAuth/OAuth2/Service/RunKeeper.php vendored
View File

@@ -1,105 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* RunKeeper service.
*
* @link http://runkeeper.com/developer/healthgraph/registration-authorization
*/
class RunKeeper extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.runkeeper.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationUri(array $additionalParameters = array())
{
$parameters = array_merge(
$additionalParameters,
array(
'client_id' => $this->credentials->getConsumerId(),
'redirect_uri' => $this->credentials->getCallbackUrl(),
'response_type' => 'code',
)
);
$parameters['scope'] = implode(' ', $this->scopes);
// Build the url
$url = clone $this->getAuthorizationEndpoint();
foreach ($parameters as $key => $val) {
$url->addToQuery($key, $val);
}
return $url;
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://runkeeper.com/apps/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://runkeeper.com/apps/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

92
vendor/OAuth/OAuth2/Service/Salesforce.php vendored
View File

@@ -1,92 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Service\AbstractService;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class SalesforceService extends AbstractService
{
/**
* Scopes
*
* @var string
*/
const SCOPE_API = 'api',
SCOPE_REFRESH_TOKEN = 'refresh_token';
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://login.salesforce.com/services/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://na1.salesforce.com/services/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function parseRequestTokenResponse($responseBody)
{
parse_str($responseBody, $data);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (!isset($data['oauth_callback_confirmed']) || $data['oauth_callback_confirmed'] !== 'true') {
throw new TokenResponseException('Error in retrieving token.');
}
return $this->parseAccessTokenResponse($responseBody);
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
// Salesforce tokens evidently never expire...
$token->setEndOfLife(StdOAuth2Token::EOL_NEVER_EXPIRES);
unset($data['access_token']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getExtraOAuthHeaders()
{
return array('Accept' => 'application/json');
}
}

37
vendor/OAuth/OAuth2/Service/ServiceInterface.php vendored
View File

@@ -1,37 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Service\ServiceInterface as BaseServiceInterface;
use OAuth\Common\Http\Uri\UriInterface;
/**
* Defines the common methods across OAuth 2 services.
*/
interface ServiceInterface extends BaseServiceInterface
{
/**
* Authorization methods for various services
*/
const AUTHORIZATION_METHOD_HEADER_OAUTH = 0;
const AUTHORIZATION_METHOD_HEADER_BEARER = 1;
const AUTHORIZATION_METHOD_QUERY_STRING = 2;
const AUTHORIZATION_METHOD_QUERY_STRING_V2 = 3;
const AUTHORIZATION_METHOD_QUERY_STRING_V3 = 4;
/**
* Retrieves and stores/returns the OAuth2 access token after a successful authorization.
*
* @param string $code The access code from the callback.
*
* @return TokenInterface $token
*
* @throws TokenResponseException
*/
public function requestAccessToken($code);
}

77
vendor/OAuth/OAuth2/Service/SoundCloud.php vendored
View File

@@ -1,77 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class SoundCloud extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.soundcloud.com/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://soundcloud.com/connect');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://api.soundcloud.com/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
if (isset($data['expires_in'])) {
$token->setLifetime($data['expires_in']);
unset($data['expires_in']);
}
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
$token->setExtraParams($data);
return $token;
}
}

98
vendor/OAuth/OAuth2/Service/Ustream.php vendored
View File

@@ -1,98 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Ustream extends AbstractService
{
/**
* Scopes
*
* @var string
*/
const SCOPE_OFFLINE = 'offline';
const SCOPE_BROADCASTER = 'broadcaster';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri, true);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.ustream.tv/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.ustream.tv/oauth2/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.ustream.tv/oauth2/token');
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getExtraOAuthHeaders()
{
return array('Authorization' => 'Basic ' . $this->credentials->getConsumerSecret());
}
}

109
vendor/OAuth/OAuth2/Service/Vkontakte.php vendored
View File

@@ -1,109 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Vkontakte extends AbstractService
{
/**
* Defined scopes
*
* @link http://vk.com/dev/permissions
*/
const SCOPE_EMAIL = 'email';
const SCOPE_NOTIFY = 'notify';
const SCOPE_FRIENDS = 'friends';
const SCOPE_PHOTOS = 'photos';
const SCOPE_AUDIO = 'audio';
const SCOPE_VIDEO = 'video';
const SCOPE_DOCS = 'docs';
const SCOPE_NOTES = 'notes';
const SCOPE_PAGES = 'pages';
const SCOPE_APP_LINK = '';
const SCOPE_STATUS = 'status';
const SCOPE_OFFERS = 'offers';
const SCOPE_QUESTIONS = 'questions';
const SCOPE_WALL = 'wall';
const SCOPE_GROUPS = 'groups';
const SCOPE_MESSAGES = 'messages';
const SCOPE_NOTIFICATIONS = 'notifications';
const SCOPE_STATS = 'stats';
const SCOPE_ADS = 'ads';
const SCOPE_OFFLINE = 'offline';
const SCOPE_NOHTTPS = 'nohttps';
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://api.vk.com/method/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://oauth.vk.com/authorize');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://oauth.vk.com/access_token');
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']);
$token->setLifeTime($data['expires_in']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
/**
* {@inheritdoc}
*/
protected function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_QUERY_STRING;
}
}

82
vendor/OAuth/OAuth2/Service/Yammer.php vendored
View File

@@ -1,82 +0,0 @@
<?php
namespace OAuth\OAuth2\Service;
use OAuth\OAuth2\Token\StdOAuth2Token;
use OAuth\Common\Http\Exception\TokenResponseException;
use OAuth\Common\Http\Uri\Uri;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Uri\UriInterface;
class Yammer extends AbstractService
{
public function __construct(
CredentialsInterface $credentials,
ClientInterface $httpClient,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
parent::__construct($credentials, $httpClient, $storage, $scopes, $baseApiUri);
if (null === $baseApiUri) {
$this->baseApiUri = new Uri('https://www.yammer.com/api/v1/');
}
}
/**
* {@inheritdoc}
*/
public function getAuthorizationEndpoint()
{
return new Uri('https://www.yammer.com/dialog/oauth');
}
/**
* {@inheritdoc}
*/
public function getAccessTokenEndpoint()
{
return new Uri('https://www.yammer.com/oauth2/access_token.json');
}
/**
* {@inheritdoc}
*/
public function getAuthorizationMethod()
{
return static::AUTHORIZATION_METHOD_HEADER_BEARER;
}
/**
* {@inheritdoc}
*/
protected function parseAccessTokenResponse($responseBody)
{
$data = json_decode($responseBody, true);
if (null === $data || !is_array($data)) {
throw new TokenResponseException('Unable to parse response.');
} elseif (isset($data['error'])) {
throw new TokenResponseException('Error in retrieving token: "' . $data['error'] . '"');
}
$token = new StdOAuth2Token();
$token->setAccessToken($data['access_token']['token']);
$token->setLifetime($data['access_token']['expires_at']);
if (isset($data['refresh_token'])) {
$token->setRefreshToken($data['refresh_token']);
unset($data['refresh_token']);
}
unset($data['access_token']);
unset($data['expires_in']);
$token->setExtraParams($data);
return $token;
}
}

13
vendor/OAuth/OAuth2/Token/StdOAuth2Token.php vendored
View File

@@ -1,13 +0,0 @@
<?php
namespace OAuth\OAuth2\Token;
use OAuth\Common\Token\AbstractToken;
/**
* Standard OAuth2 token implementation.
* Implements OAuth\OAuth2\Token\TokenInterface for any functionality that might not be provided by AbstractToken.
*/
class StdOAuth2Token extends AbstractToken implements TokenInterface
{
}

9
vendor/OAuth/OAuth2/Token/TokenInterface.php vendored
View File

@@ -1,9 +0,0 @@
<?php
namespace OAuth\OAuth2\Token;
use OAuth\Common\Token\TokenInterface as BaseTokenInterface;
interface TokenInterface extends BaseTokenInterface
{
}

229
vendor/OAuth/ServiceFactory.php vendored
View File

@@ -1,229 +0,0 @@
<?php
/**
* OAuth service factory.
*
* PHP version 5.4
*
* @category OAuth
* @author David Desberg <david@daviddesberg.com>
* @author Pieter Hordijk <info@pieterhordijk.com>
* @copyright Copyright (c) 2013 The authors
* @license http://www.opensource.org/licenses/mit-license.html MIT License
*/
namespace OAuth;
use OAuth\Common\Service\ServiceInterface;
use OAuth\Common\Consumer\CredentialsInterface;
use OAuth\Common\Storage\TokenStorageInterface;
use OAuth\Common\Http\Client\ClientInterface;
use OAuth\Common\Http\Client\StreamClient;
use OAuth\Common\Http\Uri\UriInterface;
use OAuth\Common\Exception\Exception;
use OAuth\OAuth1\Signature\Signature;
class ServiceFactory
{
/**
*@var ClientInterface
*/
protected $httpClient;
/**
* @var array
*/
protected $serviceClassMap = array(
'OAuth1' => array(),
'OAuth2' => array()
);
/**
* @var array
*/
protected $serviceBuilders = array(
'OAuth2' => 'buildV2Service',
'OAuth1' => 'buildV1Service',
);
/**
* @param ClientInterface $httpClient
*
* @return ServiceFactory
*/
public function setHttpClient(ClientInterface $httpClient)
{
$this->httpClient = $httpClient;
return $this;
}
/**
* Register a custom service to classname mapping.
*
* @param string $serviceName Name of the service
* @param string $className Class to instantiate
*
* @return ServiceFactory
*
* @throws Exception If the class is nonexistent or does not implement a valid ServiceInterface
*/
public function registerService($serviceName, $className)
{
if (!class_exists($className)) {
throw new Exception(sprintf('Service class %s does not exist.', $className));
}
$reflClass = new \ReflectionClass($className);
foreach (array('OAuth2', 'OAuth1') as $version) {
if ($reflClass->implementsInterface('OAuth\\' . $version . '\\Service\\ServiceInterface')) {
$this->serviceClassMap[$version][ucfirst($serviceName)] = $className;
return $this;
}
}
throw new Exception(sprintf('Service class %s must implement ServiceInterface.', $className));
}
/**
* Builds and returns oauth services
*
* It will first try to build an OAuth2 service and if none found it will try to build an OAuth1 service
*
* @param string $serviceName Name of service to create
* @param CredentialsInterface $credentials
* @param TokenStorageInterface $storage
* @param array|null $scopes If creating an oauth2 service, array of scopes
* @param UriInterface|null $baseApiUri
*
* @return ServiceInterface
*/
public function createService(
$serviceName,
CredentialsInterface $credentials,
TokenStorageInterface $storage,
$scopes = array(),
UriInterface $baseApiUri = null
) {
if (!$this->httpClient) {
// for backwards compatibility.
$this->httpClient = new StreamClient();
}
foreach ($this->serviceBuilders as $version => $buildMethod) {
$fullyQualifiedServiceName = $this->getFullyQualifiedServiceName($serviceName, $version);
if (class_exists($fullyQualifiedServiceName)) {
return $this->$buildMethod($fullyQualifiedServiceName, $credentials, $storage, $scopes, $baseApiUri);
}
}
return null;
}
/**
* Gets the fully qualified name of the service
*
* @param string $serviceName The name of the service of which to get the fully qualified name
* @param string $type The type of the service to get (either OAuth1 or OAuth2)
*
* @return string The fully qualified name of the service
*/
private function getFullyQualifiedServiceName($serviceName, $type)
{
$serviceName = ucfirst($serviceName);
if (isset($this->serviceClassMap[$type][$serviceName])) {
return $this->serviceClassMap[$type][$serviceName];
}
return '\\OAuth\\' . $type . '\\Service\\' . $serviceName;
}
/**
* Builds v2 services
*
* @param string $serviceName The fully qualified service name
* @param CredentialsInterface $credentials
* @param TokenStorageInterface $storage
* @param array|null $scopes Array of scopes for the service
* @param UriInterface|null $baseApiUri
*
* @return ServiceInterface
*
* @throws Exception
*/
private function buildV2Service(
$serviceName,
CredentialsInterface $credentials,
TokenStorageInterface $storage,
array $scopes,
UriInterface $baseApiUri = null
) {
return new $serviceName(
$credentials,
$this->httpClient,
$storage,
$this->resolveScopes($serviceName, $scopes),
$baseApiUri
);
}
/**
* Resolves scopes for v2 services
*
* @param string $serviceName The fully qualified service name
* @param array $scopes List of scopes for the service
*
* @return array List of resolved scopes
*/
private function resolveScopes($serviceName, array $scopes)
{
$reflClass = new \ReflectionClass($serviceName);
$constants = $reflClass->getConstants();
$resolvedScopes = array();
foreach ($scopes as $scope) {
$key = strtoupper('SCOPE_' . $scope);
if (array_key_exists($key, $constants)) {
$resolvedScopes[] = $constants[$key];
} else {
$resolvedScopes[] = $scope;
}
}
return $resolvedScopes;
}
/**
* Builds v1 services
*
* @param string $serviceName The fully qualified service name
* @param CredentialsInterface $credentials
* @param TokenStorageInterface $storage
* @param array $scopes
* @param UriInterface $baseApiUri
*
* @return ServiceInterface
*
* @throws Exception
*/
private function buildV1Service(
$serviceName,
CredentialsInterface $credentials,
TokenStorageInterface $storage,
$scopes,
UriInterface $baseApiUri = null
) {
if (!empty($scopes)) {
throw new Exception(
'Scopes passed to ServiceFactory::createService but an OAuth1 service was requested.'
);
}
return new $serviceName($credentials, $this->httpClient, $storage, new Signature($credentials), $baseApiUri);
}
}

13
vendor/OAuth/bootstrap.php vendored
View File

@@ -1,13 +0,0 @@
<?php
/*
* Bootstrap the library.
*/
namespace OAuth;
require_once __DIR__ . '/Common/AutoLoader.php';
$autoloader = new Common\AutoLoader(__NAMESPACE__, dirname(__DIR__));
$autoloader->register();

20
vendor/Parsedown/LICENSE.txt vendored
View File

@@ -1,20 +0,0 @@
The MIT License (MIT)
Copyright (c) 2013 Emanuil Rusev, erusev.com
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

1423
vendor/Parsedown/Parsedown.php vendored
View File

File diff suppressed because it is too large Load Diff

155
vendor/PicoDb/Database.php vendored
View File

@@ -1,155 +0,0 @@
<?php
namespace PicoDb;
class Database
{
private static $instances = array();
private $logs = array();
private $pdo;
public function __construct(array $settings)
{
if (! isset($settings['driver'])) {
throw new \LogicException('You must define a database driver.');
}
switch ($settings['driver']) {
case 'sqlite':
require_once __DIR__.'/Drivers/Sqlite.php';
$this->pdo = new Sqlite($settings);
break;
case 'mysql':
require_once __DIR__.'/Drivers/Mysql.php';
$this->pdo = new Mysql($settings);
break;
case 'postgres':
require_once __DIR__.'/Drivers/Postgres.php';
$this->pdo = new Postgres($settings);
break;
default:
throw new \LogicException('This database driver is not supported.');
}
$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
}
public static function bootstrap($name, \Closure $callback)
{
self::$instances[$name] = $callback;
}
public static function get($name)
{
if (! isset(self::$instances[$name])) {
throw new \LogicException('No database instance created with that name.');
}
if (is_callable(self::$instances[$name])) {
self::$instances[$name] = call_user_func(self::$instances[$name]);
}
return self::$instances[$name];
}
public function setLogMessage($message)
{
$this->logs[] = $message;
}
public function getLogMessages()
{
return $this->logs;
}
public function getConnection()
{
return $this->pdo;
}
public function closeConnection()
{
$this->pdo = null;
}
public function escapeIdentifier($value)
{
// Do not escape custom query
if (strpos($value, '.') !== false || strpos($value, ' ') !== false) {
return $value;
}
return $this->pdo->escapeIdentifier($value);
}
public function execute($sql, array $values = array())
{
try {
$this->setLogMessage($sql);
$this->setLogMessage(implode(', ', $values));
$rq = $this->pdo->prepare($sql);
$rq->execute($values);
return $rq;
}
catch (\PDOException $e) {
if ($this->pdo->inTransaction()) $this->pdo->rollback();
$this->setLogMessage($e->getMessage());
return false;
}
}
public function startTransaction()
{
if (! $this->pdo->inTransaction()) {
$this->pdo->beginTransaction();
}
}
public function closeTransaction()
{
if ($this->pdo->inTransaction()) {
$this->pdo->commit();
}
}
public function cancelTransaction()
{
if ($this->pdo->inTransaction()) {
$this->pdo->rollback();
}
}
public function table($table_name)
{
require_once __DIR__.'/Table.php';
return new Table($this, $table_name);
}
public function schema()
{
require_once __DIR__.'/Schema.php';
return new Schema($this);
}
}

75
vendor/PicoDb/Drivers/Mysql.php vendored
View File

@@ -1,75 +0,0 @@
<?php
namespace PicoDb;
class Mysql extends \PDO {
private $schema_table = 'schema_version';
public function __construct(array $settings)
{
$required_atttributes = array(
'hostname',
'username',
'password',
'database',
'charset',
);
foreach ($required_atttributes as $attribute) {
if (! isset($settings[$attribute])) {
throw new \LogicException('This configuration parameter is missing: "'.$attribute.'"');
}
}
$dsn = 'mysql:host='.$settings['hostname'].';dbname='.$settings['database'];
$options = array(
\PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES '.$settings['charset']
);
parent::__construct($dsn, $settings['username'], $settings['password'], $options);
if (isset($settings['schema_table'])) {
$this->schema_table = $settings['schema_table'];
}
}
public function getSchemaVersion()
{
$this->exec("CREATE TABLE IF NOT EXISTS `".$this->schema_table."` (`version` INT DEFAULT '0')");
$rq = $this->prepare('SELECT `version` FROM `'.$this->schema_table.'`');
$rq->execute();
$result = $rq->fetch(\PDO::FETCH_ASSOC);
if (isset($result['version'])) {
return (int) $result['version'];
}
else {
$this->exec('INSERT INTO `'.$this->schema_table.'` VALUES(0)');
}
return 0;
}
public function setSchemaVersion($version)
{
$rq = $this->prepare('UPDATE `'.$this->schema_table.'` SET `version`=?');
$rq->execute(array($version));
}
public function getLastId()
{
return $this->lastInsertId();
}
public function escapeIdentifier($value)
{
return '`'.$value.'`';
}
}

73
vendor/PicoDb/Drivers/Postgres.php vendored
View File

@@ -1,73 +0,0 @@
<?php
namespace PicoDb;
class Postgres extends \PDO {
private $schema_table = 'schema_version';
public function __construct(array $settings)
{
$required_atttributes = array(
'hostname',
'username',
'password',
'database',
);
foreach ($required_atttributes as $attribute) {
if (! isset($settings[$attribute])) {
throw new \LogicException('This configuration parameter is missing: "'.$attribute.'"');
}
}
$dsn = 'pgsql:host='.$settings['hostname'].';dbname='.$settings['database'];
parent::__construct($dsn, $settings['username'], $settings['password']);
if (isset($settings['schema_table'])) {
$this->schema_table = $settings['schema_table'];
}
}
public function getSchemaVersion()
{
$this->exec("CREATE TABLE IF NOT EXISTS ".$this->schema_table." (version SMALLINT DEFAULT 0)");
$rq = $this->prepare('SELECT version FROM '.$this->schema_table.'');
$rq->execute();
$result = $rq->fetch(\PDO::FETCH_ASSOC);
if (isset($result['version'])) {
return (int) $result['version'];
}
else {
$this->exec('INSERT INTO '.$this->schema_table.' VALUES(0)');
}
return 0;
}
public function setSchemaVersion($version)
{
$rq = $this->prepare('UPDATE '.$this->schema_table.' SET version=?');
$rq->execute(array($version));
}
public function getLastId()
{
$rq = $this->prepare('SELECT LASTVAL()');
$rq->execute();
return $rq->fetchColumn();
}
public function escapeIdentifier($value)
{
return $value;
}
}

56
vendor/PicoDb/Drivers/Sqlite.php vendored
View File

@@ -1,56 +0,0 @@
<?php
namespace PicoDb;
class Sqlite extends \PDO {
public function __construct(array $settings)
{
$required_atttributes = array(
'filename',
);
foreach ($required_atttributes as $attribute) {
if (! isset($settings[$attribute])) {
throw new \LogicException('This configuration parameter is missing: "'.$attribute.'"');
}
}
parent::__construct('sqlite:'.$settings['filename']);
$this->exec('PRAGMA foreign_keys = ON');
}
public function getSchemaVersion()
{
$rq = $this->prepare('PRAGMA user_version');
$rq->execute();
$result = $rq->fetch(\PDO::FETCH_ASSOC);
if (isset($result['user_version'])) {
return (int) $result['user_version'];
}
return 0;
}
public function setSchemaVersion($version)
{
$this->exec('PRAGMA user_version='.$version);
}
public function getLastId()
{
return $this->lastInsertId();
}
public function escapeIdentifier($value)
{
return '"'.$value.'"';
}
}

54
vendor/PicoDb/Schema.php vendored
View File

@@ -1,54 +0,0 @@
<?php
namespace PicoDb;
class Schema
{
protected $db = null;
public function __construct(Database $db)
{
$this->db = $db;
}
public function check($last_version = 1)
{
$current_version = $this->db->getConnection()->getSchemaVersion();
if ($current_version < $last_version) {
return $this->migrateTo($current_version, $last_version);
}
return true;
}
public function migrateTo($current_version, $next_version)
{
try {
$this->db->startTransaction();
for ($i = $current_version + 1; $i <= $next_version; $i++) {
$function_name = '\Schema\version_'.$i;
if (function_exists($function_name)) {
call_user_func($function_name, $this->db->getConnection());
$this->db->getConnection()->setSchemaVersion($i);
}
}
$this->db->closeTransaction();
}
catch (\PDOException $e) {
$this->db->setLogMessage($function_name.' => '.$e->getMessage());
$this->db->cancelTransaction();
return false;
}
return true;
}
}

444
vendor/PicoDb/Table.php vendored
View File

@@ -1,444 +0,0 @@
<?php
namespace PicoDb;
class Table
{
const SORT_ASC = 'ASC';
const SORT_DESC = 'DESC';
private $table_name = '';
private $sql_limit = '';
private $sql_offset = '';
private $sql_order = '';
private $joins = array();
private $conditions = array();
private $or_conditions = array();
private $is_or_condition = false;
private $columns = array();
private $values = array();
private $distinct = false;
private $group_by = array();
private $db;
public function __construct(Database $db, $table_name)
{
$this->db = $db;
$this->table_name = $table_name;
return $this;
}
public function save(array $data)
{
if (! empty($this->conditions)) {
return $this->update($data);
}
else {
return $this->insert($data);
}
}
/**
* Update
*
* Note: Do not use `rowCount()` the behaviour is different across drivers
*/
public function update(array $data)
{
$columns = array();
$values = array();
foreach ($data as $column => $value) {
$columns[] = $this->db->escapeIdentifier($column).'=?';
$values[] = $value;
}
foreach ($this->values as $value) {
$values[] = $value;
}
$sql = sprintf(
'UPDATE %s SET %s %s',
$this->db->escapeIdentifier($this->table_name),
implode(', ', $columns),
$this->conditions()
);
$result = $this->db->execute($sql, $values);
return $result !== false;
}
public function insert(array $data)
{
$columns = array();
foreach ($data as $column => $value) {
$columns[] = $this->db->escapeIdentifier($column);
}
$sql = sprintf(
'INSERT INTO %s (%s) VALUES (%s)',
$this->db->escapeIdentifier($this->table_name),
implode(', ', $columns),
implode(', ', array_fill(0, count($data), '?'))
);
return false !== $this->db->execute($sql, array_values($data));
}
public function remove()
{
$sql = sprintf(
'DELETE FROM %s %s',
$this->db->escapeIdentifier($this->table_name),
$this->conditions()
);
$result = $this->db->execute($sql, $this->values);
return $result !== false && $result->rowCount() > 0;
}
public function listing($key, $value)
{
$this->columns($key, $value);
$listing = array();
$results = $this->findAll();
if ($results) {
foreach ($results as $result) {
$listing[$result[$key]] = $result[$value];
}
}
return $listing;
}
public function findAll()
{
$rq = $this->db->execute($this->buildSelectQuery(), $this->values);
if (false === $rq) return false;
return $rq->fetchAll(\PDO::FETCH_ASSOC);
}
public function findAllByColumn($column)
{
$this->columns = array($column);
$rq = $this->db->execute($this->buildSelectQuery(), $this->values);
if (false === $rq) return false;
return $rq->fetchAll(\PDO::FETCH_COLUMN, 0);
}
public function findOne()
{
$this->limit(1);
$result = $this->findAll();
return isset($result[0]) ? $result[0] : null;
}
public function findOneColumn($column)
{
$this->limit(1);
$this->columns = array($column);
$rq = $this->db->execute($this->buildSelectQuery(), $this->values);
if (false === $rq) return false;
return $rq->fetchColumn();
}
public function buildSelectQuery()
{
foreach ($this->columns as $key => $value) {
$this->columns[$key] = $this->db->escapeIdentifier($value);
}
return sprintf(
'SELECT %s %s FROM %s %s %s %s %s %s %s',
$this->distinct ? 'DISTINCT' : '',
empty($this->columns) ? '*' : implode(', ', $this->columns),
$this->db->escapeIdentifier($this->table_name),
implode(' ', $this->joins),
$this->conditions(),
empty($this->group_by) ? '' : 'GROUP BY '.implode(', ', $this->group_by),
$this->sql_order,
$this->sql_limit,
$this->sql_offset
);
}
public function count()
{
$sql = sprintf(
'SELECT COUNT(*) FROM %s'.$this->conditions().$this->sql_order.$this->sql_limit.$this->sql_offset,
$this->db->escapeIdentifier($this->table_name)
);
$rq = $this->db->execute($sql, $this->values);
if (false === $rq) return false;
$result = $rq->fetchColumn();
return $result ? (int) $result : 0;
}
public function join($table, $foreign_column, $local_column)
{
$this->joins[] = sprintf(
'LEFT JOIN %s ON %s=%s',
$this->db->escapeIdentifier($table),
$this->db->escapeIdentifier($table).'.'.$this->db->escapeIdentifier($foreign_column),
$this->db->escapeIdentifier($this->table_name).'.'.$this->db->escapeIdentifier($local_column)
);
return $this;
}
public function conditions()
{
if (! empty($this->conditions)) {
return ' WHERE '.implode(' AND ', $this->conditions);
}
else {
return '';
}
}
public function addCondition($sql)
{
if ($this->is_or_condition) {
$this->or_conditions[] = $sql;
}
else {
$this->conditions[] = $sql;
}
}
public function beginOr()
{
$this->is_or_condition = true;
$this->or_conditions = array();
return $this;
}
public function closeOr()
{
$this->is_or_condition = false;
if (! empty($this->or_conditions)) {
$this->conditions[] = '('.implode(' OR ', $this->or_conditions).')';
}
return $this;
}
public function orderBy($column, $order = self::SORT_ASC)
{
$order = strtoupper($order);
$order = $order === self::SORT_ASC || $order === self::SORT_DESC ? $order : self::SORT_ASC;
if ($this->sql_order === '') {
$this->sql_order = ' ORDER BY '.$this->db->escapeIdentifier($column).' '.$order;
}
else {
$this->sql_order .= ', '.$this->db->escapeIdentifier($column).' '.$order;
}
return $this;
}
public function asc($column)
{
if ($this->sql_order === '') {
$this->sql_order = ' ORDER BY '.$this->db->escapeIdentifier($column).' '.self::SORT_ASC;
}
else {
$this->sql_order .= ', '.$this->db->escapeIdentifier($column).' '.self::SORT_ASC;
}
return $this;
}
public function desc($column)
{
if ($this->sql_order === '') {
$this->sql_order = ' ORDER BY '.$this->db->escapeIdentifier($column).' '.self::SORT_DESC;
}
else {
$this->sql_order .= ', '.$this->db->escapeIdentifier($column).' '.self::SORT_DESC;
}
return $this;
}
public function limit($value)
{
if (! is_null($value)) $this->sql_limit = ' LIMIT '.(int) $value;
return $this;
}
public function offset($value)
{
if (! is_null($value)) $this->sql_offset = ' OFFSET '.(int) $value;
return $this;
}
public function groupBy()
{
$this->group_by = \func_get_args();
return $this;
}
public function columns()
{
$this->columns = \func_get_args();
return $this;
}
public function distinct()
{
$this->columns = \func_get_args();
$this->distinct = true;
return $this;
}
public function __call($name, array $arguments)
{
$column = $arguments[0];
$sql = '';
switch (strtolower($name)) {
case 'in':
if (isset($arguments[1]) && is_array($arguments[1]) && ! empty($arguments[1])) {
$sql = sprintf(
'%s IN (%s)',
$this->db->escapeIdentifier($column),
implode(', ', array_fill(0, count($arguments[1]), '?'))
);
}
break;
case 'notin':
if (isset($arguments[1]) && is_array($arguments[1]) && ! empty($arguments[1])) {
$sql = sprintf(
'%s NOT IN (%s)',
$this->db->escapeIdentifier($column),
implode(', ', array_fill(0, count($arguments[1]), '?'))
);
}
break;
case 'like':
$sql = sprintf('%s LIKE ?', $this->db->escapeIdentifier($column));
break;
case 'eq':
case 'equal':
case 'equals':
$sql = sprintf('%s = ?', $this->db->escapeIdentifier($column));
break;
case 'neq':
case 'notequal':
case 'notequals':
$sql = sprintf('%s != ?', $this->db->escapeIdentifier($column));
break;
case 'gt':
case 'greaterthan':
$sql = sprintf('%s > ?', $this->db->escapeIdentifier($column));
break;
case 'lt':
case 'lowerthan':
$sql = sprintf('%s < ?', $this->db->escapeIdentifier($column));
break;
case 'gte':
case 'greaterthanorequals':
$sql = sprintf('%s >= ?', $this->db->escapeIdentifier($column));
break;
case 'lte':
case 'lowerthanorequals':
$sql = sprintf('%s <= ?', $this->db->escapeIdentifier($column));
break;
case 'isnull':
$sql = sprintf('%s IS NULL', $this->db->escapeIdentifier($column));
break;
case 'notnull':
$sql = sprintf('%s IS NOT NULL', $this->db->escapeIdentifier($column));
break;
}
if ($sql !== '') {
$this->addCondition($sql);
if (isset($arguments[1])) {
if (is_array($arguments[1])) {
foreach ($arguments[1] as $value) {
$this->values[] = $value;
}
}
else {
$this->values[] = $arguments[1];
}
}
}
return $this;
}
}

44
vendor/SimpleValidator/Base.php vendored
View File

@@ -1,44 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
abstract class Base
{
protected $field = '';
protected $error_message = '';
protected $data = array();
abstract public function execute(array $data);
public function __construct($field, $error_message)
{
$this->field = $field;
$this->error_message = $error_message;
}
public function getErrorMessage()
{
return $this->error_message;
}
public function getField()
{
return $this->field;
}
}

67
vendor/SimpleValidator/Validator.php vendored
View File

@@ -1,67 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Validator
{
private $data = array();
private $errors = array();
private $validators = array();
public function __construct(array $data, array $validators)
{
$this->data = $data;
$this->validators = $validators;
}
public function execute()
{
$result = true;
foreach ($this->validators as $validator) {
if (! $validator->execute($this->data)) {
$this->addError(
$validator->getField(),
$validator->getErrorMessage()
);
$result = false;
}
}
return $result;
}
public function addError($field, $message)
{
if (! isset($this->errors[$field])) {
$this->errors[$field] = array();
}
$this->errors[$field][] = $message;
}
public function getErrors()
{
return $this->errors;
}
}

33
vendor/SimpleValidator/Validators/Alpha.php vendored
View File

@@ -1,33 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Alpha extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
if (! ctype_alpha($data[$this->field])) {
return false;
}
}
return true;
}
}

33
vendor/SimpleValidator/Validators/AlphaNumeric.php vendored
View File

@@ -1,33 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class AlphaNumeric extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
if (! ctype_alnum($data[$this->field])) {
return false;
}
}
return true;
}
}

48
vendor/SimpleValidator/Validators/Date.php vendored
View File

@@ -1,48 +0,0 @@
<?php
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
use \DateTime;
class Date extends Base
{
private $formats = array();
public function __construct($field, $error_message, array $formats)
{
parent::__construct($field, $error_message);
$this->formats = $formats;
}
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
foreach ($this->formats as $format) {
if ($this->isValidDate($data[$this->field], $format) === true) {
return true;
}
}
return false;
}
return true;
}
public function isValidDate($value, $format)
{
$date = DateTime::createFromFormat($format, $value);
if ($date !== false) {
$errors = DateTime::getLastErrors();
if ($errors['error_count'] === 0 && $errors['warning_count'] === 0) {
$timestamp = $date->getTimestamp();
return $timestamp > 0 ? true : false;
}
}
return false;
}
}

81
vendor/SimpleValidator/Validators/Email.php vendored
View File

@@ -1,81 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Email extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
// I use the same validation method as Firefox
// http://hg.mozilla.org/mozilla-central/file/cf5da681d577/content/html/content/src/nsHTMLInputElement.cpp#l3967
$value = $data[$this->field];
$length = strlen($value);
// If the email address begins with a '@' or ends with a '.',
// we know it's invalid.
if ($value[0] === '@' || $value[$length - 1] === '.') {
return false;
}
// Check the username
for ($i = 0; $i < $length && $value[$i] !== '@'; ++$i) {
$c = $value[$i];
if (! (ctype_alnum($c) || $c === '.' || $c === '!' || $c === '#' || $c === '$' ||
$c === '%' || $c === '&' || $c === '\'' || $c === '*' || $c === '+' ||
$c === '-' || $c === '/' || $c === '=' || $c === '?' || $c === '^' ||
$c === '_' || $c === '`' || $c === '{' || $c === '|' || $c === '}' ||
$c === '~')) {
return false;
}
}
// There is no domain name (or it's one-character long),
// that's not a valid email address.
if (++$i >= $length) return false;
if (($i + 1) === $length) return false;
// The domain name can't begin with a dot.
if ($value[$i] === '.') return false;
// Parsing the domain name.
for (; $i < $length; ++$i) {
$c = $value[$i];
if ($c === '.') {
// A dot can't follow a dot.
if ($value[$i - 1] === '.') return false;
}
elseif (! (ctype_alnum($c) || $c === '-')) {
// The domain characters have to be in this list to be valid.
return false;
}
}
}
return true;
}
}

43
vendor/SimpleValidator/Validators/Equals.php vendored
View File

@@ -1,43 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Equals extends Base
{
private $field2;
public function __construct($field1, $field2, $error_message)
{
parent::__construct($field1, $error_message);
$this->field2 = $field2;
}
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
if (! isset($data[$this->field2])) return false;
return $data[$this->field] === $data[$this->field2];
}
return true;
}
}

36
vendor/SimpleValidator/Validators/GreaterThan.php vendored
View File

@@ -1,36 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
class GreaterThan extends Base
{
private $min;
public function __construct($field, $error_message, $min)
{
parent::__construct($field, $error_message);
$this->min = $min;
}
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
return $data[$this->field] > $this->min;
}
return true;
}
}

42
vendor/SimpleValidator/Validators/Integer.php vendored
View File

@@ -1,42 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Integer extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
if (is_string($data[$this->field])) {
if ($data[$this->field][0] === '-') {
return ctype_digit(substr($data[$this->field], 1));
}
return ctype_digit($data[$this->field]);
}
else {
return is_int($data[$this->field]);
}
}
return true;
}
}

33
vendor/SimpleValidator/Validators/Ip.php vendored
View File

@@ -1,33 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Ip extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
if (! filter_var($data[$this->field], FILTER_VALIDATE_IP)) {
return false;
}
}
return true;
}
}

48
vendor/SimpleValidator/Validators/Length.php vendored
View File

@@ -1,48 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class Length extends Base
{
private $min;
private $max;
public function __construct($field, $error_message, $min, $max)
{
parent::__construct($field, $error_message);
$this->min = $min;
$this->max = $max;
}
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
$length = mb_strlen($data[$this->field], 'UTF-8');
if ($length < $this->min || $length > $this->max) {
return false;
}
}
return true;
}
}

37
vendor/SimpleValidator/Validators/MacAddress.php vendored
View File

@@ -1,37 +0,0 @@
<?php
/*
* This file is part of Simple Validator.
*
* (c) Frédéric Guillot <contact@fredericguillot.com>
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
namespace SimpleValidator\Validators;
use SimpleValidator\Base;
/**
* @author Frédéric Guillot <contact@fredericguillot.com>
*/
class MacAddress extends Base
{
public function execute(array $data)
{
if (isset($data[$this->field]) && $data[$this->field] !== '') {
$groups = explode(':', $data[$this->field]);
if (count($groups) !== 6) return false;
foreach ($groups as $group) {
if (! ctype_xdigit($group)) return false;
}
}
return true;
}
}

Some files were not shown because too many files have changed in this diff Show More