/**
* @inheritDoc
*/
public function execute()
{
$client = new Client(['headers' => $this->request->getHeaders()]);
try {
$response = $client->request($this->request->getMethod(), $this->request->getUri(), ['body' => $this->request->getBody()->getContents()]);
} catch (ClientException $e) {
$this->error = ['status' => $e->getResponse()->getStatusCode(), 'content' => $e->getResponse()->getBody()->getContents()];
return false;
}
$this->output = $response->getBody()->getContents();
return true;
}
/**
* HttpRequest constructor.
* @param Request $request
* @param bool $streamed
*/
public function __construct(Request $request, $streamed = false)
{
$this->isStreamed = $streamed;
$body = $request->getBody()->getContents();
if ($length = strlen($body)) {
$request = $request->withHeader('Content-Length', $length);
}
// Build HTTP request
$req[] = "{$request->getMethod()} {$request->getRequestTarget()} HTTP/{$request->getProtocolVersion()}";
$headers = $request->getHeaders();
foreach ($headers as $key => $v) {
if (is_array($v)) {
$v = Arrays::first($v);
}
$req[] = "{$key}: {$v}";
}
$req[] = '';
if ($body) {
$req[] = $body;
} else {
$req[] = '';
}
$this->data = implode("\r\n", $req);
$this->parserCallable = [$this, 'parseHead'];
}
/**
* {@InheritDoc}
*/
public function send(Request $request)
{
$guzzleRequest = $this->client->createRequest($request->getMethod(), $request->getUri(), $request->getHeaders(), $request->getBody());
$guzzleResponse = $guzzleRequest->send();
$response = new Response($guzzleResponse->getStatusCode(), $guzzleResponse->getHeaders()->toArray(), $guzzleResponse->getBody(true));
return $response;
}
/**
* {@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;
}
/**
* Assert that the value a a parameter in the body of a request is equal to
* $bodyParameterValue
*
* @param string $bodyParameterKey
* Name of a parameter in the body of the request
* @param string $bodyParameterValue
* Expected value of that parameter
* @param Request $request
* @return void
*/
public function assertRequestBodyParameterSame($bodyParameterKey, $bodyParameterValue, Request $request)
{
// Parse the request body into an array
$body = (string) $request->getBody();
$body = json_decode($body, true);
// Assert the body contains the participant details
$this->assertSame($bodyParameterValue, $body[$bodyParameterKey]);
}
private function authenticateRequest(HttpRequest $request)
{
$body = JsonRpc\json_decode((string) $request->getBody()->getContents(), true);
$body['auth'] = $this->auth_token;
$json_body = JsonRpc\json_encode($body);
$request = $request->withBody(Psr7\stream_for($json_body));
return $request;
}
public function testConstructorDoesNotReadStreamBody()
{
$streamIsRead = false;
$body = Psr7\FnStream::decorate(Psr7\stream_for(''), ['__toString' => function () use(&$streamIsRead) {
$streamIsRead = true;
return '';
}]);
$r = new Request('GET', '/', [], $body);
$this->assertFalse($streamIsRead);
$this->assertSame($body, $r->getBody());
}
public function addSignatureToGuzzle6Request(\GuzzleHttp\Psr7\Request $request, $api_token, $secret)
{
$method = $request->getMethod();
// build URL without parameters
$uri = $request->getUri();
$url = $this->buildURLPrefix($uri->getScheme(), $uri->getHost(), $uri->getPort()) . $uri->getPath();
// get parameters
if ($method == 'GET') {
parse_str($uri->getQuery(), $parameters);
} else {
// assume json
$json_string = $request->getBody();
$parameters = strlen($json_string) ? json_decode($json_string) : [];
}
// get signature
$signature_info = $this->createSignatureParameters($method, $url, $parameters, $api_token, $secret);
// add http headers
$request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-API-TOKEN', $api_token);
$request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-NONCE', $signature_info['nonce']);
$request = $request->withHeader('X-' . $this->auth_header_namespace . '-AUTH-SIGNATURE', $signature_info['signature']);
return $request;
}
/**
* {@inheritDoc}
*/
public function getBody()
{
return $this->request->getBody();
}
/**
* 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;
}
}
}
public function testCanConstructWithBody()
{
$r = new Request('GET', '/', [], 'baz');
$this->assertEquals('baz', (string) $r->getBody());
}
private function getMetadata(Request $request)
{
$lines = explode(PHP_EOL, (string) $request->getBody());
return json_decode($lines[5], true);
}
/**
* Handle an error. We handle errors by throwing an exception.
*
* @param string $error An error code representing the error
* (use_underscore_separators).
* @param string|null $message The error message.
* @param GuzzleRequest|null $request Optional. The Guzzle request object.
* @param ResponseInterface|null $response Optional. The Guzzle response object.
*
* @return void
* @throws BoxViewException
*/
protected static function error($error, $message = null, $request = null, $response = null)
{
if (!empty($request)) {
$message .= "\n";
$message .= 'Method: ' . $request->getMethod() . "\n";
$message .= 'URL: ' . $request->getUri() . "\n";
$message .= 'Headers: ' . json_encode($request->getHeaders()) . "\n";
$message .= 'Request Body: ' . $request->getBody() . "\n";
}
if (!empty($response)) {
$message .= "\n";
$message .= 'Response Body: ' . $response->getBody() . "\n";
}
$exception = new BoxViewException($message);
$exception->errorCode = $error;
throw $exception;
}
public function testProperBodyReading()
{
$request = new Request('PUT', 'http://example.local', [], \GuzzleHttp\Psr7\stream_for('foo=bar&hello=world'));
$request->getBody()->getContents();
$curl = $this->curlFormatter->format($request);
$this->assertContains("-d 'foo=bar&hello=world'", $curl);
$this->assertContains("-X PUT", $curl);
}
/**
* Return notification
*
* @param Request $request Incoming request
* @param string $webhookUrl Webhook url
*
* @return Notification
* @throws NotificationException
*/
public function hookNotificaion(Request $request, $webhookUrl)
{
$signature = $request->getHeaderLine('X-Signature');
$requestBody = $request->getBody();
$errorMessages = NotificationException::getErrorMessages();
if ($signature !== $this->getSignature($webhookUrl, $requestBody)) {
throw new NotificationException($errorMessages[NotificationException::BAD_SIGNATURE], NotificationException::BAD_SIGNATURE);
}
if ($body = json_decode($requestBody, true)) {
if (time() - (int) $body['timestamp'] > 86400) {
throw new NotificationException($errorMessages[NotificationException::EXPIRED_TIMESTAMP], NotificationException::EXPIRED_TIMESTAMP);
}
return new Notification($body['receiver_email'], $body['transaction_code'], $body['transaction_status'], $body['sender_name'], $body['sender_email'], $body['sender_phone'], $body['sender_address'], $body['amount'], $body['currency'], $body['expiry'], $body['timestamp'], $body['nonce'], $body['payload'], $body['description']);
}
}
