/**
* @throws HttpException
*/
protected function handleError()
{
$body = (string) $this->response->getBody();
$code = (int) $this->response->getStatusCode();
$content = json_decode($body);
throw new HttpException(isset($content->message) ? $content->message : 'Request not processed.', $code);
}
public function testConstruct()
{
$response = new Response(\Psc\Net\Service::OK, array('blubb' => 'blubb'));
$this->assertEquals(array('blubb' => 'blubb'), $response->getBody());
$this->assertEquals(\Psc\Net\Service::OK, $response->getStatus());
$this->assertInstanceOf('Psc\\Net\\ServiceResponse', $response);
}
/**
* @throws HttpException
*/
protected function handleError()
{
$body = (string) $this->response->getBody();
$code = (int) $this->response->getStatusCode();
$content = json_decode($body);
$error = $content->errors[0];
throw new HttpException(isset($error) ? $error->description : 'Request not processed.', $code);
}
public function testResponseValues()
{
$resource = $this->prophesize(Resource::CLASS);
$resource->asJson()->willReturn('foobar');
$response = new Response($resource->reveal());
$this->assertSame(200, $response->getStatusCode());
$this->assertSame('application/hal+json', $response->getHeaderLine('Content-Type'));
$this->assertSame('foobar', (string) $response->getBody());
}
/**
* @param Response $response
*/
function __construct(Response $response)
{
$this->response = $response;
if (($h = $response->getHeader("Content-Type", Header::class)) && $h->match("application/json", Header::MATCH_WORD) && ($failure = json_decode($response->getBody()))) {
$message = $failure->message;
if (isset($failure->errors)) {
$this->errors = (array) $failure->errors;
}
} else {
$message = trim($response->getBody()->toString());
}
if (!strlen($message)) {
$message = $response->getTransferInfo("error");
}
if (!strlen($message)) {
$message = $response->getResponseStatus();
}
parent::__construct($message, $response->getResponseCode(), null);
}
/**
* Verify basic functionality of the response object.
*
* @test
* @covers ::__construct
* @covers ::getHttpCode
* @covers ::getHeaders
* @covers ::getBody
*
* @return void
*/
public function construct()
{
$httpCode = 200;
$headers = ['Content-Type' => 'text/json'];
$body = ['doesnt' => 'matter'];
$response = new Response($httpCode, $headers, $body);
$this->assertSame($httpCode, $response->getHttpCode());
$this->assertSame($headers, $response->getHeaders());
$this->assertSame($body, $response->getBody());
}
/**
* Sends the body of the response to the client.
*
* @return void
*/
protected function sendBody()
{
$body = $this->response->getBody();
// Response::setBody() makes an is_callable check when setting the value.
// is_callable is a fairly heavy function due to the checks it has to
// perform compared to is_string, so this is a safe and fast way, though
// not necessarily intuitive way to structure the handling.
if (is_string($body)) {
echo $body;
} else {
call_user_func($body);
}
}
public function __construct(Response $parent)
{
$status = $parent->getStatus();
$convertToJson = false;
$ok = self::statusIsOK($status);
if ($ok) {
$contentType = $parent->getHeader('Content-Type');
if (!empty($contentType)) {
$convertToJson = stristr($contentType, '/json') !== false;
}
}
$bodyString = $parent->getBody();
parent::__construct($convertToJson ? json_decode($bodyString) : $bodyString, $parent->getHeaders(), $status);
$this->ok = $ok;
}
public function respond(Response $response)
{
$ajaxResponse = array();
$ajaxResponse['components'] = array();
$ajaxResponse['header'] = array();
$ajaxResponse['script'] = $this->script;
$headerResponse = new HeaderResponse($response);
foreach ($this->components as $component) {
$response->clean();
$component->beforePageRender();
$component->render();
$value = $response->getBody();
$response->clean();
array_push($ajaxResponse['components'], array('id' => $component->getMarkupId(), 'value' => $value));
$this->renderComponentHeader($component, $response, $headerResponse);
$value = $response->getBody();
array_push($ajaxResponse['header'], $value);
$response->clean();
}
FeedbackModel::get()->cleanup();
header('Content-Type: application/json');
print json_encode($ajaxResponse);
}
/**
* Import handler for the endpoint's underlying data
*
* \seekat\Call will call this when the request will have finished.
*
* @param Response $response
* @return API self
* @throws UnexpectedValueException
* @throws RequestException
* @throws \Exception
*/
function import(Response $response) : API
{
$this->__log->info(__FUNCTION__ . ": " . $response->getInfo(), ["url" => (string) $this->__url]);
if ($response->getResponseCode() >= 400) {
$e = new RequestException($response);
$this->__log->critical(__FUNCTION__ . ": " . $e->getMessage(), ["url" => (string) $this->__url]);
throw $e;
}
if (!($type = $response->getHeader("Content-Type", Header::class))) {
$e = new RequestException($response);
$this->__log->error(__FUNCTION__ . ": Empty Content-Type -> " . $e->getMessage(), ["url" => (string) $this->__url]);
throw $e;
}
try {
$this->__type = new ContentType($type);
$this->__data = $this->__type->parseBody($response->getBody());
if ($link = $response->getHeader("Link", Header::class)) {
$this->__links = new Links($link);
}
} catch (\Exception $e) {
$this->__log->error(__FUNCTION__ . ": " . $e->getMessage(), ["url" => (string) $this->__url]);
throw $e;
}
return $this;
}
/**
* Convert guzzle response to data
*
* @param Response $response GuzzleHttp\Response
*
* @return string or array data
*/
public function format($response)
{
$data = (string) $response->getBody();
if ($this->option('json') === true) {
return $data;
}
return json_decode($data);
}
protected function render($data = null, $nested = true)
{
extract($data);
ob_start();
// Include view files
if ($nested) {
include $this->getTemplatePathname('header.php');
}
foreach ($this->getTemplates() as $tpl) {
include $tpl;
}
if ($nested) {
include $this->getTemplatePathname('footer.php');
}
$output = ob_get_clean();
Response::getBody()->write($output);
return Container::get('response');
}
/**
* Get the response body as string
*
* This method returns the body of the HTTP response (the content), as it
* should be in it's readable version - that is, after decoding it (if it
* was decoded), deflating it (if it was gzip compressed), etc.
*
* If you want to get the raw body (as transfered on wire) use
* $this->getRawBody() instead.
*
* @return string
*/
public function getBody()
{
if ($this->stream != null) {
$this->readStream();
}
return parent::getBody();
}
/**
* Get the response body after the request has been sent.
* If redirects were allowed and several responses were received, the data references the last received response.
* @return string
*/
public function getResponseBody()
{
return $this->response->getBody();
}
/**
* Parse a signed JSON response
*
* @param Response $response
* @param SignaturePublicKey $publicKey
* @return mixed
* @throws SignatureFailed
* @throws TransferException
*/
public function parseSignedJSON(Response $response, SignaturePublicKey $publicKey)
{
$code = $response->getStatusCode();
if ($code >= 200 && $code < 300) {
$body = (string) $response->getBody();
$firstNewLine = \strpos($body, "\n");
// There should be a newline immediately after the base64urlsafe-encoded signature
if ($firstNewLine !== self::ENCODED_SIGNATURE_LENGTH) {
throw new SignatureFailed(\sprintf("First newline found at position %s, expected %d.\n%s", \print_r($firstNewLine, true), \print_r(self::ENCODED_SIGNATURE_LENGTH, true), Base64::encode($body)));
}
$sig = Base64UrlSafe::decode(Binary::safeSubstr($body, 0, 88));
$msg = Binary::safeSubstr($body, 89);
if (!Asymmetric::verify($msg, $publicKey, $sig, true)) {
throw new SignatureFailed();
}
return \Airship\parseJSON($msg, true);
}
throw new TransferException();
}
public function testGetBodyReturnsBody()
{
$response = new Response('foo');
$this->assertSame('foo', $response->getBody());
}
/**
* Gravatar profile
*
* @param Response $response Response from gravatar.com
*/
public function __construct(Response $response)
{
$this->responseData = \array_merge($this->responseData, \unserialize($response->getBody())["entry"][0]);
}
/**
* Use Response object to modify headers and output body
* @param Response $response
*/
private function respond(Response $response)
{
foreach ($response->getHeaders() as $header) {
header($header);
}
echo $response->getBody();
}
public static function fromResponse(Response $response)
{
return new self($response->getBody(), $response->getContentType());
}
public function testConstructBodyNull()
{
$response = new Response(["test" => "value"], null);
$this->assertNull($response->getBody());
}
/**
* @param Response $response
*
* @return \Generator
*
* @resolve string
*/
protected function getResponseBody(Response $response) : \Generator
{
$data = '';
$stream = $response->getBody();
while ($stream->isReadable()) {
$data .= (yield $stream->read());
}
return $data;
}
public function render(array $data = [], $nested = true)
{
// Set data to display in page
if (isset($data['template'])) {
throw new \InvalidArgumentException("Duplicate template key found");
}
$data = Container::get('hooks')->fire('view.alter_data', $data);
extract($data);
ob_start();
// Include view files
if ($nested) {
include $this->getTemplatePathname('header.php');
}
foreach ($this->getTemplates() as $tpl) {
include $tpl;
}
if ($nested) {
include $this->getTemplatePathname('footer.php');
}
$output = ob_get_clean();
$response = Response::getBody()->write($output);
return $response;
}
private function assertResponseBody($body)
{
$response = new Response($body);
$this->assertEquals($body, $response->getBody());
}
