/**
* @param string $url
* @param string $method
* @param array $options
* @return \GuzzleHttp\Message\Request
*/
protected function createRequest($url, $method = 'GET', $options = array())
{
// $defaults = array('future' => true, 'debug' => true);
$defaults = array('future' => true);
$req = $this->client->createRequest($method, $url, array_merge($defaults, $options));
return $req;
}
/**
* Method to handle the Subscribe Request to the Hub
*/
public function subscribe()
{
// Start empty $hubUrl variable
$hubUrl = '';
// Check if the Hub URL finishes with a / or not to be able to create the correct subscribe URL
if (preg_match("/\\/\$/", $this->current_options['hub_url'])) {
$hubUrl = $this->current_options['hub_url'] . 'subscribe';
} else {
$hubUrl = $this->current_options['hub_url'] . '/subscribe';
}
// Json Data needed to send to the Hub for Subscription
$subscribeJson = json_encode(array("callbackUrl" => esc_url($this->callbackUrl), "topicId" => esc_url($this->current_options['topic_url'])), JSON_UNESCAPED_SLASHES);
$subscribeRequest = $this->guzzleClient->createRequest('POST', $hubUrl);
$subscribeRequest->setHeader('Content-Type', 'application/json');
$subscribeRequest->setBody(Stream::factory($subscribeJson));
$subscribeResponse = $this->guzzleClient->send($subscribeRequest);
// Check if Response is 200, 202 or 204 and add a log message otherwise log error message
if (in_array($subscribeResponse->getStatusCode(), array(200, 202, 204))) {
HubLogger::log('Your Subscription request is being processed. Check back later to see if you are fully Subscribed', $subscribeResponse->getStatusCode());
return true;
} else {
HubLogger::error('Error issuing Subscribe request to the Hub. Please make sure all your details are correct', $subscribeResponse->getStatusCode());
return false;
}
}
/**
* @param IpnEntity $ipn
* @return bool
*/
public function forwardIpn(IpnEntity $ipn)
{
$urls = $ipn->getForwardUrls();
if (!empty($urls)) {
$requests = [];
foreach ($urls as $url) {
$request = $this->guzzle->createRequest('post', $url);
$request->setHeader($this->customHeader, $this->getKey());
if (in_array($url, $this->disabledJsonFormatting)) {
$request->getQuery()->merge($ipn->toArray());
} else {
$request->setHeader('content-type', 'application/json');
if ($this->formatter) {
$response = $this->formatter->formatJsonResponse($ipn);
} else {
$response = ['ipn' => $ipn->toArray()];
}
$request->setBody(Stream::factory(json_encode($response)));
}
$requests[] = $request;
}
$this->guzzle->sendAll($requests, ['parallel' => $this->maxRequests]);
return true;
}
return false;
}
/**
* Handles all api calls
*
* @param string $uri
* @param array $params
* @return array
* @throws \Exception
*/
public function getRequest($uri, array $params = [])
{
// validate uri
if (!is_string($uri)) {
throw new InvalidArgumentException("Invalid uri {$uri} submitted.");
}
// make sure uri isn't absolute - remove first / if there
if ($uri[0] == '/') {
$uri = substr($uri, 1);
}
try {
$request = $this->client->createRequest('GET', $uri, ['query' => $params]);
$response = $this->client->send($request)->json();
// cairo returns 200 even for errors so check response for error
// errors array can have multiple, which do we show? create one string for all?
if (!empty($response['errors'])) {
throw RequestException::create($request, new Response($response['errors'][0]['code'], [], null, ['reason_phrase' => $response['errors'][0]['messages'][0]]));
}
} catch (RequestException $e) {
$message = $e->getRequest() . "\n";
if ($e->hasResponse()) {
$message .= $e->getResponse() . "\n";
}
throw new Exception($message, $e->getCode());
}
return $response;
}
/**
* Performs a upload request
*
* @param Request $request
* @return An array attactment objects
*/
public function upload(Request $request)
{
$this->emit('before.request', [$request, &$this->headers]);
$files = $request->getFiles();
if ($files->count() == 0) {
throw new \UnexpectedValueException("Upload request must have at least one file.");
}
$options = ['headers' => $this->headers, 'cookies' => true, 'verify' => false];
if (!empty($this->_authToken)) {
$options['cookies'] = array('ZM_AUTH_TOKEN' => $this->_authToken);
}
$httpRequest = $this->_httpClient->createRequest('POST', $this->_location, $options);
$postBody = $httpRequest->getBody();
$postBody->setField('requestId', $request->getRequestId());
foreach ($files as $file) {
$postBody->addFile(new PostFile(basename($file), fopen($file, 'r')));
}
$httpRequest->setQuery(['fmt' => 'raw,extended']);
try {
$response = $this->_httpClient->send($httpRequest);
$this->emit('after.request', [$response, $response->getHeaders()]);
} catch (BadResponseException $ex) {
if ($ex->hasResponse()) {
$response = $ex->getResponse();
$this->emit('after.request', [$response, $response->getHeaders()]);
}
throw $ex;
}
return $this->_parseResponse($response);
}
/**
* Guzzle 4 Request method implementation
*
* @param string $httpMethod
* @param string $path
* @param array $params
* @param null $version
* @param bool $isAuthorization
*
* @return Response|mixed
* @throws ClientException
* @throws AuthorizeException
* @throws ServerException
* @throws Error
*/
public function request($httpMethod = 'GET', $path = '', $params = array(), $version = null, $isAuthorization = false)
{
$guzzleClient = new GuzzleClient();
switch ($httpMethod) {
case 'GET':
$request = $guzzleClient->createRequest($httpMethod, $path, array('query' => $params));
break;
default:
$request = $guzzleClient->createRequest($httpMethod, $path, array('body' => $params));
}
try {
$res = $guzzleClient->send($request);
} catch (GuzzleException\ClientException $e) {
//catch error 404
$error_message = $e->getResponse();
if ($isAuthorization) {
throw new AuthorizeException($error_message, $e->getCode(), $e->getPrevious());
} else {
throw new ClientException($error_message, $e->getCode(), $e->getPrevious());
}
} catch (GuzzleException\ServerException $e) {
throw new ServerException($e, $e->getCode(), $e->getPrevious());
} catch (GuzzleException\BadResponseException $e) {
throw new Error($e->getResponse(), $e->getCode(), $e->getPrevious());
}
$response = new Response($res->json(), $res->getCode());
return $response;
}
/**
* @param string $method
* @param string $uri
* @param array $options
*
* @return ResponseInterface
*/
public function request($method, $uri, array $options = [])
{
$this->lazyLoadGuzzle();
$this->lastRequest = $this->guzzle->createRequest($method, $uri, $options);
$response = $this->guzzle->send($this->lastRequest);
return $response;
}
protected function createBaseRequest($accessToken, $method, $baseUrl)
{
$request = $this->client->createRequest($method, $baseUrl);
// $request->getQuery()->set("api_key", $this->apiKey);
$request->setHeaders($this->getHeaders($accessToken));
return $request;
}
/**
* @return array
*/
public function doRequest() : array
{
$this->generateRequestOptions();
$this->authenticator->authenticate($this);
$request = $this->httpClient->createRequest($this->method, $this->getUrl(), $this->requestOptions);
return $this->httpClient->send($request)->json();
}
/**
* {@InheritDoc}
*/
public function send(Request $request)
{
$guzzleRequest = $this->client->createRequest($request->getMethod(), $request->getUri(), ['headers' => $request->getHeaders()]);
$guzzleRequest->setBody(Stream::factory($request->getBody()));
$guzzleResponse = $this->getClient()->send($guzzleRequest);
$response = new Response($guzzleResponse->getStatusCode(), $guzzleResponse->getHeaders(), $guzzleResponse->getBody(true));
return $response;
}
protected function sendGuzzleRequest($http_verb = 'GET', $url, $data = null)
{
if (date(time()) >= Session::get('oauth_token_expiry')) {
$this->refreshAccessToken();
}
$request = $this->client->createRequest($http_verb, $url, ['json' => $data, 'headers' => ['Authorization' => 'Bearer ' . Session::get('access_token')]]);
return $this->client->send($request)->json();
}
/**
* Broadcast the given event.
*
* @param array $channels
* @param string $event
* @param array $payload
* @return void
*/
public function broadcast(array $channels, $event, array $payload = array())
{
foreach ($channels as $channel) {
$payload = ['text' => array_merge(['eventtype' => $event], $payload)];
$request = $this->client->createRequest('POST', '/pub?id=' . $channel, ['json' => $payload]);
$response = $this->client->send($request);
}
}
public function execute($method, $uri, $data)
{
$request = $this->guzzleClient->createRequest($method, $uri, $data);
/** @var ResponseInterface $response */
/** @noinspection PhpVoidFunctionResultUsedInspection */
$response = $this->guzzleClient->send($request);
return new Response($response);
}
/**
* @param Request $request
* @return GuzzleRequest
*/
protected function prepareRequest(Request $request)
{
$guzzleRequest = $this->client->createRequest($request->getMethod(), (string) $request->getUrl(), array('version' => $request->getProtocolVersion()));
if (null !== ($content = $request->getContent())) {
$guzzleRequest->setBody(Stream::factory($content));
}
$guzzleRequest->setHeaders($this->prepareHeaders($request));
return $guzzleRequest;
}
protected function buildBaseRequest()
{
$request = $this->client->createRequest(Settings::GET, Settings::BASE_URL . $this->ENDPOINT_URL, Settings::$CREATE_REQUEST_OPTIONS);
if ($this->supportsLocalization) {
$query = $request->getQuery();
$query->set(Settings::LANG, Settings::$LOCALE);
}
return $request;
}
/** @test */
public function shouldReturnAResponseForARequestObject()
{
$mockResponse = $this->createResponse(new Response(200, ['Content-Type' => 'application/json'], Stream::factory(json_encode(['hello' => 'world', 'howareyou' => 'today']))));
$request = $this->guzzleClient->createRequest('PUT', 'http://example.com/foo', ['query' => ['faz' => 'baz'], 'body' => json_encode(['shakeyo' => 'body']), 'headers' => ['Content-Type' => 'application/json']]);
$this->httpMock->shouldReceiveRequest($request)->andRespondWith($mockResponse);
$actualResponse = $this->guzzleClient->put('http://example.com/foo', ['query' => ['faz' => 'baz'], 'body' => json_encode(['shakeyo' => 'body']), 'headers' => ['Content-Type' => 'application/json']]);
$this->httpMock->verify();
$this->assertSame($mockResponse, $actualResponse);
}
/**
* @param string $content
* @return \GuzzleHttp\Message\Request
*/
private function buildRequest($content)
{
$url = $this->configuration->getUrl();
$method = $this->configuration->getMethod();
$request = $this->client->createRequest($method, $url);
$body = $request->getBody();
$body->setField('message', $content);
return $request;
}
/**
* A simple wrapper for calling any valid service.
*
* This function accepts strings so that it is flexible enough to handle
* new APIs released by CCB without requiring code updates.
*
* @param string $httpMethod Either "GET" or "POST"
* @param string $serviceName
* @param array $args
*
* @return SimpleXMLElement
*/
public function srv($httpMethod, $serviceName, array $args = [])
{
$url = "https://{$this->church}.ccbchurch.com/api.php";
if (!isset($args['query'])) {
$args['query'] = [];
}
$args['query']['srv'] = $serviceName;
$request = $this->client->createRequest($httpMethod, $url, $args);
return $this->client->send($request)->xml();
}
/**
* @param $topic string
* @param $args array|null
* @param $kwargs array|null
* @return array JSON decoded response
* @throws \Exception
*/
public function publish($topic, array $args = NULL, array $kwargs = NULL)
{
$request = $this->client->createRequest('POST', NULL, array('body' => $this->prepareBody($topic, $args, $kwargs), 'query' => $this->prepareQuery()));
try {
$response = $this->client->send($request);
} catch (\Exception $e) {
throw $e;
}
return $response->json();
}
/**
* Performs a request to the QBank API.
*
* @param string $endpoint The API endpoint URL to request.
* @param array $parameters The parameters to send.
* @param string $method The HTTP verb to use.
* @param CachePolicy $cachePolicy The custom caching policy to use.
* @param bool $delayed If the request should be delayed until destruction.
*
* @return array The response result.
*
* @throws RequestException
* @throws ResponseException
*/
protected function call($endpoint, array $parameters = [], $method = self::METHOD_GET, CachePolicy $cachePolicy = null, $delayed = false)
{
$cachePolicy = $cachePolicy !== null ? $cachePolicy : $this->cachePolicy;
if ($delayed) {
$this->delayedRequests[] = $this->client->createRequest(strtoupper($method), $endpoint, $parameters);
$this->logger->debug('Request to QBank added to delayed queue. ' . strtoupper($method) . ' ' . $endpoint, ['endpoint' => $endpoint, 'parameters' => $parameters, 'method' => $method]);
return [];
}
if ($cachePolicy->isEnabled() && ($method == self::METHOD_GET || $method == self::METHOD_POST && preg_match('/v\\d+\\/search/', $endpoint)) && $this->cache->contains(md5($endpoint . json_encode($parameters)))) {
/** @var string $response */
$response = $this->cache->fetch(md5($endpoint . json_encode($parameters)));
$this->logger->info('Using cached response. ' . strtoupper($method) . ' ' . $endpoint, ['endpoint' => $endpoint, 'parameters' => $parameters, 'method' => $method, 'response' => substr(print_r($response, true), 0, 4096)]);
return $response;
}
try {
$start = microtime(true);
/** @var ResponseInterface $response */
$response = $this->client->{$method}($endpoint, $parameters);
$this->logger->debug('Request to QBank sent. ' . strtoupper($method) . ' ' . $endpoint, ['endpoint' => $endpoint, 'parameters' => $parameters, 'time' => number_format(round((microtime(true) - $start) * 1000), 0, '.', ' ') . ' ms', 'method' => $method, 'response' => substr($response->getBody(), 0, 4096)]);
$data = null;
if (in_array('application/json', array_map('trim', explode(';', $response->getHeader('Content-type'))))) {
try {
$data = $response->json();
} catch (\RuntimeException $re) {
$this->logger->error('Error while receiving response from QBank. ' . strtoupper($method) . ' ' . $endpoint, ['message' => 'Response not in json format.', 'endpoint' => $endpoint, 'parameters' => $parameters, 'method' => $method, 'response' => substr($response->getBody(), 0, 4096)]);
throw new ResponseException('Error while receiving response from QBank: Response not in json format.');
}
} else {
return $response->getBody()->__toString();
}
if ($cachePolicy->isEnabled() && $cachePolicy->getCacheType() == CachePolicy::EVERYTHING && ($method == self::METHOD_GET || $method == self::METHOD_POST && preg_match('/v\\d+\\/search/', $endpoint))) {
$this->cache->save(md5($endpoint . json_encode($parameters)), $data, $cachePolicy->getLifetime());
}
return $data;
} catch (\GuzzleHttp\Exception\RequestException $re) {
$this->logger->error('Error while sending request to QBank. ' . strtoupper($method) . ' ' . $endpoint, ['exception' => $re, 'message' => $re->getMessage(), 'endpoint' => $endpoint, 'parameters' => $parameters, 'method' => $method, 'response' => $re->hasResponse() ? substr($re->getResponse()->getBody(), 0, 4096) : '']);
$message = null;
$details = null;
if ($re->hasResponse() && strpos($re->getResponse()->getHeader('content-type'), 'application/json') === 0) {
$content = $re->getResponse()->json();
if (!empty($content['error'])) {
$details = $content['error'];
}
if (isset($content['error']['message'])) {
$message = ' [info]' . $content['error']['message'];
}
if (isset($content['error']['errors']) && is_array($content['error']['errors'])) {
foreach ($content['error']['errors'] as $key => $error) {
$message .= "\n\t{$key}: {$error}";
}
}
}
throw new RequestException('Error while sending request to QBank: ' . $re->getMessage() . $message, $re->hasResponse() ? $re->getResponse()->getStatusCode() : 0, $re, $details);
}
}
/**
* {@inheritdoc}
*/
public function execute(HttpRequestInterface $request)
{
$guzzleRequest = $this->guzzleClient->createRequest($request->getMethod(), $request->getUrl(), ['query' => $request->getParams(), 'headers' => $request->getHeaders()]);
try {
$clientResponse = $this->guzzleClient->send($guzzleRequest);
} catch (RequestException $e) {
// Re-throw guzzle exception as our own
throw new HttpTransportException("Guzzle exception", 0, $e);
}
return (new HttpResponse())->setBody($clientResponse->getBody())->setHeaders($clientResponse->getHeaders());
}
/**
* @param $topic string
* @param $args array|null
* @param $kwargs array|null
* @return array JSON decoded response
* @throws \Exception
*/
public function publish($topic, array $args = null, array $kwargs = null)
{
$jsonBody = $this->prepareBody($topic, $args, $kwargs);
$request = $this->client->createRequest('POST', null, array('body' => $jsonBody, 'query' => $this->prepareSignature($jsonBody)));
try {
$response = $this->client->send($request);
} catch (\Exception $e) {
throw new PublishRequestException($e->getMessage(), 500, $e);
}
return $response->json();
}
public function testCanForeach()
{
$c = new Client();
$requests = [$c->createRequest('GET', 'http://test.com'), $c->createRequest('POST', 'http://test.com'), $c->createRequest('PUT', 'http://test.com')];
$t = new TransactionIterator(new \ArrayIterator($requests), $c, []);
$methods = [];
foreach ($t as $trans) {
$this->assertInstanceOf('GuzzleHttp\\Adapter\\TransactionInterface', $trans);
$methods[] = $trans->getRequest()->getMethod();
}
$this->assertEquals(['GET', 'POST', 'PUT'], $methods);
}
/**
* @param RequestableInterface $apiRequest
*
* @return bool|\GuzzleHttp\Message\ResponseInterface
*/
public function send(RequestableInterface $apiRequest)
{
$request = $this->guzzleClient->createRequest($apiRequest->getMethod(), $apiRequest->getUrl(), $apiRequest->getOptions());
try {
return $this->guzzleClient->send($request);
} catch (ClientException $e) {
if (null !== $this->logger) {
$this->logger->alert($e->getMessage());
}
return false;
}
}
/**
* Wraps HTTP call into a good mould
*
* @param string $method
* @param string $endpoint
* @param array $data
* @return Horntell\Http\Response
* @throws Horntell\Errors\*
*/
public function send($method, $endpoint, $data = [])
{
try {
$request = $this->client->createRequest($method, $endpoint, ['body' => json_encode($data)]);
return new Response($this->client->send($request));
} catch (GuzzleExceptions\RequestException $e) {
// pass the exception to a helper method,
// which will figure our what kind of
// exception to throw
return $this->handleError($e);
}
}
protected function newAPIRequest($method, $path, $data = [])
{
$api_path = '/api/v1' . $path;
$client = new GuzzleClient(['base_url' => $this->swapbot_url]);
$request = $client->createRequest($method, $api_path);
if ($data and ($method == 'POST' or $method == 'PATCH')) {
$request = $client->createRequest($method, $api_path, ['json' => $data]);
} else {
if ($method == 'GET') {
$request = $client->createRequest($method, $api_path, ['query' => $data]);
}
}
// add auth
// $this->getAuthenticationGenerator()->addSignatureToGuzzleRequest($request, $this->api_token, $this->api_secret_key);
// send request
try {
$response = $client->send($request);
} catch (RequestException $e) {
if ($response = $e->getResponse()) {
// interpret the response and error message
$code = $response->getStatusCode();
try {
$json = $response->json();
} catch (Exception $parse_json_exception) {
// could not parse json
$json = null;
}
if ($json and isset($json['message'])) {
// throw an XChainException with the errorName
if (isset($json['errorName'])) {
$swapbot_exception = new XChainException($json['message'], $code);
$swapbot_exception->setErrorName($json['errorName']);
throw $swapbot_exception;
}
// generic exception
throw new Exception($json['message'], $code);
}
}
// if no response, then just throw the original exception
throw $e;
}
$code = $response->getStatusCode();
if ($code == 204) {
// empty content
return [];
}
$json = $response->json();
if (!is_array($json)) {
throw new Exception("Unexpected response", 1);
}
return $json;
}
/**
* Download new ownCloud package
* @param Feed $feed
* @param Callable $onProgress
* @throws \UnexpectedValueException
*/
public function getOwncloud(Feed $feed, callable $onProgress)
{
if ($feed->isValid()) {
$downloadPath = $this->getBaseDownloadPath($feed);
if (!is_writable(dirname($downloadPath))) {
throw new \Exception(dirname($downloadPath) . ' is not writable.');
}
$url = $feed->getUrl();
$request = $this->httpClient->createRequest('GET', $url, ['save_to' => $downloadPath, 'timeout' => 600]);
$request->getEmitter()->on('progress', $onProgress);
$response = $this->httpClient->send($request);
$this->validateResponse($response);
}
}
/**
* Call method
* @param string $method
* @param array $data
* @return mixed
*/
public function call($method, $data = null)
{
$headers = [];
if ($data) {
$headers['Content-Type'] = 'multipart/form-data';
}
$request = $this->client->createRequest('post', $this->url . $method, ['headers' => [], 'body' => $data]);
$response = $this->client->send($request);
$results = $response->json();
if (!$results['ok']) {
throw new Exception($results['description'], $results['error_code']);
}
return $results['result'];
}
/**
* Make the request to Premailer
* @param array $params
* @return \ScottRobertson\Premailer\Response
*/
private function request(array $params = array())
{
$request = $this->client->createRequest('POST', $this->url);
$body = $request->getBody();
foreach ($params as $key => $value) {
$body->setField($key, $value);
}
try {
$response = $this->client->send($request);
} catch (\Exception $e) {
throw new \ScottRobertson\Premailer\Exception\Request($e->getMessage());
}
return new Response($response->json(), $this->client);
}
public function testSendsAllTransactions()
{
$client = new Client();
$requests = [$client->createRequest('GET', 'http://httbin.org'), $client->createRequest('HEAD', 'http://httbin.org')];
$sent = [];
$f = new FakeParallelAdapter(new MockAdapter(function ($trans) use(&$sent) {
$sent[] = $trans->getRequest()->getMethod();
return new Response(200);
}));
$tIter = new TransactionIterator($requests, $client, []);
$f->sendAll($tIter, 2);
$this->assertContains('GET', $sent);
$this->assertContains('HEAD', $sent);
}
