public function getModel($make, $model, array $options = [])
{
$resolver = new OptionsResolver();
$resolver->setDefaults(['year' => 1990, 'view' => 'basic']);
$resolver->setDefined('state');
$resolver->setRequired(['state', 'view']);
$resolver->setAllowedTypes('year', 'integer');
$resolver->setAllowedValues('state', ['new', 'used']);
$resolver->setDefault('state', function (Options $options, $previousValue) {
if ($options['year'] >= 2015) {
return 'new';
}
return $previousValue;
});
// $resolver->isDefined('state');
$options = $resolver->resolve($options);
$client = new GuzzleHttp\Client();
$queryParams = array_merge($options, ['fmt' => 'json', 'api_key' => $this->apiKey]);
$query = GuzzleHttp\Psr7\build_query($queryParams);
$request = new GuzzleHttp\Psr7\Request('GET', $this->apiEndpoint . $make . '/' . $model . '?' . $query);
/** @var ResponseInterface $response */
$response = $client->send($request);
if ($this->dispatcher) {
$this->dispatcher->dispatch(ApiCallEvent::EVENT_NAME, new GenericEvent($this, ['make' => $make, 'model' => $model, 'options' => $options]));
}
return $this->delegatingSerializer->deserialize($response->getBody(), 'json', ['type' => 'array']);
}
/**
* @param $url
* @param array $params
*
* @return \Psr\Http\Message\UriInterface
*/
private function makeUri($url, $params = array())
{
$uri = \GuzzleHttp\uri_template($this->endpoint, array_merge($this->defaults, $params));
$uri = new Psr7\Uri($uri);
// All arguments must be urlencoded (as per RFC 1738).
$query = Psr7\build_query($params, PHP_QUERY_RFC1738);
$uri = $uri->withQuery($query);
return Psr7\Uri::withQueryValue($uri, 'url', $url);
}
public function get_logout_link($returnTo = null, $client_id = null)
{
$params = [];
if ($returnTo !== null) {
$params['returnTo'] = $returnTo;
}
if ($client_id !== null) {
$params['client_id'] = $client_id;
}
$query_string = Psr7\build_query($params);
return "https://{$this->domain}/v2/logout?{$query_string}";
}
/**
* @param string $uri
* @param array $query
* @return UriInterface
*/
public function buildUriWithQuery($uri, array $query)
{
// @todo fix this hack. when using build_query booleans are converted to
// 1 or 0 which the API does not accept. this casts bools to their
// string representation
$query = array_filter($query);
foreach ($query as $k => &$v) {
if (is_bool($v)) {
$v = $v ? 'true' : 'false';
}
}
return Psr7\uri_for($uri)->withQuery(Psr7\build_query($query));
}
public function getMakes($state, $year, $view = 'full')
{
$client = new GuzzleHttp\Client();
$query = GuzzleHttp\Psr7\build_query(['api_key' => $this->apiKey, 'state' => $state, 'year' => $year, 'view' => $view, 'fmt' => 'json']);
/** @var ResponseInterface $result */
$result = $client->request('GET', $this->apiEndpoint . self::API_METHOD . '?' . $query);
if ($this->logger) {
$this->logger->log(LogLevel::INFO, sprintf('Makes response : %s', $result->getBody()));
}
if ($this->dispatcher) {
$this->dispatcher->dispatch(ApiCallEvent::EVENT_NAME, new GenericEvent($this, ['state' => $state, 'year' => $year, 'view' => $view]));
}
return $this->delegatingSerializer->deserialize((string) $result->getBody(), 'json', ['type' => 'array']);
}
/**
* Updates the request query with the developer key if auth is set to simple
*
* use Google\Auth\Middleware\SimpleMiddleware;
* use GuzzleHttp\Client;
* use GuzzleHttp\HandlerStack;
*
* $my_key = 'is not the same as yours';
* $middleware = new SimpleMiddleware(['key' => $my_key]);
* $stack = HandlerStack::create();
* $stack->push($middleware);
*
* $client = new Client([
* 'handler' => $stack,
* 'base_uri' => 'https://www.googleapis.com/discovery/v1/',
* 'auth' => 'simple'
* ]);
*
* $res = $client->get('drive/v2/rest');
*/
public function __invoke(callable $handler)
{
return function (RequestInterface $request, array $options) use($handler) {
// Requests using "auth"="scoped" will be authorized.
if (!isset($options['auth']) || $options['auth'] !== 'simple') {
return $handler($request, $options);
}
$query = Psr7\parse_query($request->getUri()->getQuery());
$params = array_merge($query, $this->config);
$uri = $request->getUri()->withQuery(Psr7\build_query($params));
$request = $request->withUri($uri);
return $handler($request, $options);
};
}
/**
* Create a pre-signed URL for Polly operation `SynthesizeSpeech`
*
* @param array $args parameters array for `SynthesizeSpeech`
* More information @see Aws\Polly\PollyClient::SynthesizeSpeech
*
* @return string
*/
public function createSynthesizeSpeechPreSignedUrl(array $args)
{
$uri = new Uri($this->getEndpoint());
$uri = $uri->withPath('/v1/speech');
// Formatting parameters follows rest-json protocol
$this->formatter = $this->formatter ?: new JsonBody($this->getApi());
$queryArray = json_decode($this->formatter->build($this->getApi()->getOperation('SynthesizeSpeech')->getInput(), $args), true);
// Mocking a 'GET' request in pre-signing the Url
$query = Psr7\build_query($queryArray);
$uri = $uri->withQuery($query);
$request = new Request('GET', $uri);
$request = $request->withBody(Psr7\stream_for(''));
$signer = new SignatureV4('polly', $this->getRegion());
return (string) $signer->presign($request, $this->getCredentials()->wait(), '+15 minutes')->getUri();
}
public function testDoesNotEncode()
{
$str = Psr7\build_query(['foo bar' => 'baz+'], false);
$this->assertEquals('foo bar=baz+', $str);
}
/**
* Sends HTTP request with the specified parameters.
*
* @param string $method HTTP method used in the request
* @param array $headers HTTP headers.
* @param array $queryParams URL query parameters.
* @param array $postParameters The HTTP POST parameters.
* @param string $path URL path
* @param int $statusCode Expected status code received in the response
* @param string $body Request body
* @param array $clientOptions Guzzle Client options
*
* @return GuzzleHttp\Psr7\Response
*/
protected function send($method, $headers, $queryParams, $postParameters, $path, $statusCode, $body = Resources::EMPTY_STRING)
{
// add query parameters into headers
$uri = $this->_psrUri;
if ($path != NULL) {
$uri = $uri->withPath($path);
}
if ($queryParams != NULL) {
$queryString = Psr7\build_query($queryParams);
$uri = $uri->withQuery($queryString);
}
// add post parameters into bodys
$actualBody = NULL;
if (empty($body)) {
if (empty($headers['content-type'])) {
$headers['content-type'] = 'application/x-www-form-urlencoded';
$actualBody = Psr7\build_query($postParameters);
}
} else {
$actualBody = $body;
}
$request = new Request($method, $uri, $headers, $actualBody);
$client = new \GuzzleHttp\Client(array_merge($this->_options['http'], array("defaults" => array("allow_redirects" => true, "exceptions" => true, "decode_content" => true), 'cookies' => true, 'verify' => false)));
$bodySize = $request->getBody()->getSize();
if ($bodySize > 0) {
$request = $request->withHeader('content-length', $bodySize);
}
// Apply filters to the requests
foreach ($this->getFilters() as $filter) {
$request = $filter->handleRequest($request);
}
try {
$response = $client->send($request);
self::throwIfError($response->getStatusCode(), $response->getReasonPhrase(), $response->getBody(), $statusCode);
return $response;
} catch (\GuzzleHttp\Exception\RequestException $e) {
if ($e->hasResponse()) {
$response = $e->getResponse();
self::throwIfError($response->getStatusCode(), $response->getReasonPhrase(), $response->getBody(), $statusCode);
return $response;
} else {
throw $e;
}
}
}
/**
* Builds the authorization Uri that the user should be redirected to.
*
* @param array $config configuration options that customize the return url
*
* @return UriInterface the authorization Url.
*
* @throws InvalidArgumentException
*/
public function buildFullAuthorizationUri(array $config = [])
{
if (is_null($this->getAuthorizationUri())) {
throw new InvalidArgumentException('requires an authorizationUri to have been set');
}
$params = array_merge(['response_type' => 'code', 'access_type' => 'offline', 'client_id' => $this->clientId, 'redirect_uri' => $this->redirectUri, 'state' => $this->state, 'scope' => $this->getScope()], $config);
// Validate the auth_params
if (is_null($params['client_id'])) {
throw new InvalidArgumentException('missing the required client identifier');
}
if (is_null($params['redirect_uri'])) {
throw new InvalidArgumentException('missing the required redirect URI');
}
if (!empty($params['prompt']) && !empty($params['approval_prompt'])) {
throw new InvalidArgumentException('prompt and approval_prompt are mutually exclusive');
}
// Construct the uri object; return it if it is valid.
$result = clone $this->authorizationUri;
$existingParams = Psr7\parse_query($result->getQuery());
$result = $result->withQuery(Psr7\build_query(array_merge($existingParams, $params)));
if ($result->getScheme() != 'https') {
throw new InvalidArgumentException('Authorization endpoint must be protected by TLS');
}
return $result;
}
private function buildRequest(array $req)
{
if ($req['query']) {
$req['uri'] = $req['uri']->withQuery(Psr7\build_query($req['query']));
}
return new Psr7\Request($req['method'], $req['uri'], $req['headers'], $req['body'], $req['version']);
}
private function buildEndpoint(Operation $operation, array $args, array $opts)
{
$varspecs = [];
// Create an associative array of varspecs used in expansions
foreach ($operation->getInput()->getMembers() as $name => $member) {
if ($member['location'] == 'uri') {
$varspecs[$member['locationName'] ?: $name] = isset($args[$name]) ? $args[$name] : null;
}
}
$relative = preg_replace_callback('/\\{([^\\}]+)\\}/', function (array $matches) use($varspecs) {
$isGreedy = substr($matches[1], -1, 1) == '+';
$k = $isGreedy ? substr($matches[1], 0, -1) : $matches[1];
if (!isset($varspecs[$k])) {
return '';
} elseif ($isGreedy) {
return str_replace('%2F', '/', rawurlencode($varspecs[$k]));
} else {
return rawurlencode($varspecs[$k]);
}
}, $operation['http']['requestUri']);
// Add the query string variables or appending to one if needed.
if (!empty($opts['query'])) {
$append = Psr7\build_query($opts['query']);
$relative .= strpos($relative, '?') ? "&{$append}" : "?{$append}";
}
// Expand path place holders using Amazon's slightly different URI
// template syntax.
return Psr7\Uri::resolve($this->endpoint, $relative);
}
/**
* @param CommandInterface $command
*
* @return RequestInterface
*/
public function commandToRequestTransformer(CommandInterface $command)
{
$name = $command->getName();
if (!isset($this->api[$name])) {
throw new CommandException('Command not found', $command);
}
$action = $this->api[$name];
$prefix = '';
if (isset($action['public']) && $command->hasParam('public')) {
$prefix = '/public';
}
$prefixes = ['system' => '/systems/{system}', 'issuer' => '/issuers/{issuer}', 'program' => '/programs/{program}'];
if (isset($action['admin_contexts'])) {
$prefix .= implode('', array_intersect_key($prefixes, array_flip($action['admin_contexts']), array_merge($command->toArray(), $this->adminContext)));
}
$path = GuzzleHttp\uri_template($prefix . $action['path'], array_merge($command->toArray(), $this->adminContext));
$headers = [];
$body = null;
if ($command->hasParam('body')) {
$headers = ['Content-Type' => 'application/json'];
$body = GuzzleHttp\json_encode($command['body']);
}
if ($command->hasParam('query')) {
$path .= '?' . Psr7\build_query($command['query']);
}
return new Psr7\Request($action['method'], $path, $headers, $body);
}
/**
* Helper method to generate an alternative form of an URL, where array indices have either
* been added or removed. foo[] is transformed into foo[0], while foo[0] is transformed into foo[].
*
* The result for URLs with both formats is undefined, or for URLs that intermingle their parameters,
* i.e. t[]=foo&b[]=bar&t[]=baz
*
* This was introduced because of differences between the URLs generated by the different clients, and
* because Facebook (at least) generates URLs were []s in URL arguments are expanded to [0] when
* requested from the backend. Since we sign our URLs, this breaks the token generation and thus breaks
* URLs when Facebook attempts to retrieve them.
*
* @param string $url The URL to generate the alternative form of
* @param int $encoding The encoding to use - from GuzzleHttp\Psr7
* @return string
*/
protected function getAlternativeURL($url, $encoding = PHP_QUERY_RFC3986)
{
$urlParts = parse_url($url);
if (!isset($urlParts['query'])) {
return $url;
}
$queryString = $urlParts['query'];
$fixKeyPattern = '#\\[[0-9]+\\]$#';
$parsed = Psr7\parse_query($queryString);
$newArguments = array();
foreach ($parsed as $key => $value) {
$fixedKey = preg_replace($fixKeyPattern, '', $key);
// if the key came out different, we're talking about a t[x] format - so we store those
// to allow for the correct sequence when regenerating the URL further below.
if ($fixedKey != $key) {
$fixedKey .= '[]';
if (!isset($newArguments[$fixedKey])) {
$newArguments[$fixedKey] = array();
}
$newArguments[$fixedKey][] = $value;
} else {
if (is_array($value) && substr($key, -2) == '[]') {
// if the value is an array, and we have the [] format already, we expand the keys
foreach ($value as $innerKey => $innerValue) {
// remove [] from the key and append the inner array key
$indexedKey = substr($key, 0, -2) . '[' . $innerKey . ']';
$newArguments[$indexedKey] = $innerValue;
}
} else {
$newArguments[$key] = $value;
}
}
}
$urlParts['query'] = Psr7\build_query($newArguments, $encoding);
$url = Urls::buildFromParseUrlParts($urlParts);
return $url;
}
/**
* Build a query string from an array of key value pairs
*
* @param array $params Query string parameters.
* @param int|false $encoding Set to false to not encode, PHP_QUERY_RFC3986
* to encode using RFC3986, or PHP_QUERY_RFC1738
* to encode using RFC1738.
* @return string
*/
public function buildQuery(array $params, $encoding = PHP_QUERY_RFC3986)
{
return Psr7\build_query($params, $encoding);
}
/**
* @param string $method
* @param string $url
* @param array $options
*
* @return RequestInterface
*/
protected function buildRequest($method, $url, array $options = [])
{
$uri = new Uri($url);
$request = new Request($method, $uri);
foreach ($options as $key => $optValue) {
switch ($key) {
case 'query':
if (is_array($optValue)) {
$optValue = build_query($optValue);
}
$uri = $uri->withQuery($optValue);
$request = $request->withUri($uri);
break;
case 'headers':
foreach ($optValue as $headerName => $headerValue) {
$request = $request->withHeader($headerName, $headerValue);
}
break;
case 'body':
$request = $request->withBody(stream_for($optValue));
break;
}
}
return $request;
}
