/**
* {@inheritdoc}
*/
public function sendRequest(RequestInterface $request)
{
$request = $this->sanitizeRequest($request);
$headers = new Headers();
foreach ($request->getHeaders() as $key => $value) {
$headers->addHeader(new GenericHeader($key, $request->getHeaderLine($key)));
}
$zendRequest = new Request();
$zendRequest->setMethod($request->getMethod());
$zendRequest->setUri((string) $request->getUri());
$zendRequest->setHeaders($headers);
$zendRequest->setContent($request->getBody()->getContents());
$options = ['httpversion' => $request->getProtocolVersion()];
if (extension_loaded('curl')) {
$options['curloptions'] = [CURLOPT_HTTP_VERSION => $this->getProtocolVersion($request->getProtocolVersion())];
}
$this->client->setOptions($options);
if ($this->client->getAdapter() instanceof ZendClient\Adapter\Curl && $request->getMethod()) {
$request = $request->withHeader('Content-Length', '0');
}
try {
$zendResponse = $this->client->send($zendRequest);
} catch (RuntimeException $exception) {
throw new NetworkException($exception->getMessage(), $request, $exception);
}
return $this->responseFactory->createResponse($zendResponse->getStatusCode(), $zendResponse->getReasonPhrase(), $zendResponse->getHeaders()->toArray(), $zendResponse->getContent(), $zendResponse->getVersion());
}
/**
*
* @param MvcEvent $event
* @return bool
*/
public function isGranted(MvcEvent $event)
{
$request = $event->getRequest();
if (!$request instanceof HttpRequest) {
return true;
}
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$clientIp = $_SERVER['HTTP_X_FORWARDED_FOR'];
} else {
$clientIp = $_SERVER['REMOTE_ADDR'];
}
if (array_key_exists($clientIp, $this->users)) {
$user = $this->users[$clientIp];
if ($this->auth->hasIdentity()) {
// do nothing
} else {
$adapter = $this->auth->getAdapter();
$request = new HttpRequest();
$request->setMethod(HttpRequest::METHOD_POST);
$request->getPost()->identity = $user['user'];
$request->getPost()->credential = $user['password'];
$request->setContent($request->getPost()->toString());
$result = $adapter->prepareForAuthentication($request);
$authenticate = $this->auth->authenticate($adapter);
if (!$authenticate->isValid()) {
error_log('FAIL');
}
}
}
return true;
}
/**
* @param Request $request
* @return Response
*/
public function request(Request $request)
{
$headers = new Headers();
$headers->addHeaders($request->getHeaders());
$zendRequest = new ZendRequest();
$zendRequest->setVersion($request->getProtocolVersion());
$zendRequest->setMethod($request->getMethod());
$zendRequest->setUri((string) $request->getUrl());
$zendRequest->setHeaders($headers);
$zendRequest->setContent($request->getContent());
/** @var ZendResponse $zendResponse */
$zendResponse = $this->client->send($zendRequest);
return new Response((string) $zendResponse->getVersion(), $zendResponse->getStatusCode(), $zendResponse->getReasonPhrase(), $zendResponse->getHeaders()->toArray(), $zendResponse->getContent());
}
/**
* @param string $collectionPath
* @param \SimpleXMLElement $element
* @return \SimpleXMLElement | null
*/
public function save($collectionPath, \SimpleXMLElement $element)
{
$uri = new Http($collectionPath);
$request = new Request();
$request->setMethod('PUT');
$headers = new Headers();
$headers->addHeader(new GenericHeader('Content-Type', 'application/xml'));
$request->setHeaders($headers);
$request->setContent($element->asXML());
$response = $this->transport->put($uri, $request);
$body = $response->getBody();
if ($response->isClientError() || empty($body)) {
return null;
}
return new \SimpleXMLElement($body);
}
public function persist(HelpReport $report)
{
$data = ['description' => 'Report generated via Ocramius CLI', 'files' => ['report.json' => ['content' => json_encode($report)]], 'public' => false];
$request = new Request();
$request->setUri('https://api.github.com/gists');
$request->setContent(json_encode($data));
$request->setMethod(Request::METHOD_POST);
$request->getHeaders()->addHeader(ContentType::fromString('Content-Type: application/json'));
$request->getHeaders()->addHeaderLine('X-Requested-With: Ocramius CLI');
$response = $this->client->send($request);
if (!$response->isSuccess()) {
throw new \UnexpectedValueException('Could not obtain a valid GIST from the github API');
}
$response = json_decode($response->getBody(), true);
return $response['html_url'];
}
/**
* Creates and configures a HTTP request based on the provided base URL and the Perun request object.
*
* @param string $baseUrl
* @param PerunRequest $perunRequest
* @param HttpRequest $httpRequest
* @return \Zend\Http\Request
*/
public function createRequest($baseUrl, PerunRequest $perunRequest)
{
/* @var $httpRequest \Zend\Http\Request */
$httpRequest = new HttpRequest();
$httpRequest->setUri($this->constructUrl($baseUrl, $perunRequest));
if ($perunRequest->isChangeState()) {
$serializedParams = $this->serializer->serialize($perunRequest->getPayload());
$httpRequest->setMethod(HttpRequest::METHOD_POST);
$httpRequest->setContent($serializedParams);
$httpRequest->getHeaders()->addHeaders(array('Content-Type' => $this->serializer->getMimeType()));
} else {
$params = $perunRequest->getPayload()->getParams();
$httpRequest->setMethod(HttpRequest::METHOD_GET);
$httpRequest->getQuery()->fromArray($params);
}
return $httpRequest;
}
public function testToken($token)
{
$request = new Request();
//ajoute des headers et modifie la requête
$request->getHeaders()->addHeaders(array('Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8'));
$request->setUri('http://localhost/rest/web/index.php/admin/publications/asc');
//URL du webservice en dehors du projet
$request->setMethod('GET');
$request->setContent(json_encode(array('a' => $token)));
$client = new Client();
$response = $client->send($request);
//envoie la requête au service REST
$data = $response->getBody();
//récupération du token
var_dump($response);
//return $data;
}
public function testValidateIncomingData()
{
$inputFilter = new SimpleInputFilter();
$inputFilterPluginManager = $this->getMock(InputFilterPluginManager::class);
$inputFilterPluginManager->expects($this->any())->method('get')->with(SimpleInputFilter::class)->willReturn($inputFilter);
$request = new HttpRequest();
$request->setPost(new Parameters(['fields1' => 'value1', 'fields2' => 'value2']));
$request->setContent(json_encode(['fields3' => 'value3']));
$controller = $this->getMock(AbstractRestfulController::class);
$controller->expects($this->at(0))->method('getRequest')->willReturn($request);
$controller->expects($this->at(1))->method('getRequest')->willReturn($request);
$plugin = new ValidateIncomingData($inputFilterPluginManager);
$plugin->setController($controller);
$expected = ['fields1' => 'value1', 'fields2' => 'value2', 'fields3' => 'value3'];
$result = $plugin(SimpleInputFilter::class);
$this->assertEquals($expected, $result);
}
public function testUpdate()
{
$userArray = array('location' => 'there', 'groups' => array(array('name' => 'groupB')), 'profile' => array('firstname' => 'Toby'));
$request = new Request();
$request->setMethod(Request::METHOD_PUT);
$request->setQuery(new Parameters(array('id' => 'superdweebie')));
$request->setContent($userArray);
$event = new MvcEvent();
$event->setRouteMatch(new RouteMatch(array()));
$event->setApplication($this->serviceManager->get('application'));
$response = null;
$this->controller->setEvent($event);
$consoleModel = $this->controller->dispatch($request, $response);
$repository = $this->documentManager->getRepository('Sds\\DoctrineExtensionsModule\\Test\\TestAsset\\Document\\User');
$this->documentManager->clear();
$user = $repository->find($this->id);
$this->assertEquals('superdweebie', $user->getId());
$this->assertEquals('there', $user->location());
$this->assertEquals('groupB', $user->getGroups()[0]);
$this->assertEquals('Toby', $user->getProfile()->getFirstName());
}
public function findOne($token, $idPublication)
{
$request = new Request();
//ajoute des headers et modifie la requête
$request->getHeaders()->addHeaders(array('Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8'));
$request->setUri('http://localhost/rest/web/index.php/admin/publications/' . $idPublication);
//URL du webservice en dehors du projet
$request->setMethod('GET');
$request->setContent(json_encode(array('a' => $token)));
$client = new Client();
$response = $client->send($request);
//envoie la requête au service REST
$statut = $response->getStatusCode();
//Traitement selon statut
if ($statut >= 200 && $statut <= 299) {
return json_decode($response->getBody(), true);
} else {
if ($statut >= 300) {
throw new \Exception();
}
}
}
public function testUnknownEventFormat()
{
$services = $this->getApplicationServiceLocator();
$emitter = $services->get('NetglueSendgrid\\Service\\EventEmitter');
$request = new HttpRequest();
$request->setContent('[{
"email": "*****@*****.**",
"timestamp": 1464173660,
"smtp-id": "<14c5d75ce93.dfd.64b469@ismtpd-555>",
"event": "whatever!",
"category": "Foo",
"sg_event_id": "lHhVQCyr17K4lAA6Xdefyg==",
"sg_message_id": "14c5d75ce93.dfd.64b469.filter0001.16648.5515E0B88.0",
"reason": "500 unknown recipient",
"status": "5.0.0"
}]');
$em = $emitter->getEventManager();
$sm = $em->getSharedManager();
$sm->attach('NetglueSendgrid\\Service\\EventEmitter', '*', [$this, 'checkInvalidEvent']);
$this->eventsFired = 0;
$emitter->receiveRequest($request);
$this->assertSame(1, $this->eventsFired);
}
private function send(Checkout $checkout)
{
$request = new Request();
$request->getHeaders()->addHeaders(array('Content-Type: application/xml; charset=ISO-8859-1'));
$request->setUri($this->options->getWsUrl());
$request->setMethod(Request::METHOD_POST);
$request->setContent($checkout->parseXML());
$client = new Client();
$response = $client->dispatch($request);
if ($response->getBody() == 'Unauthorized') {
throw new \Exception('Unauthorized access to PagSeguro');
}
$xml = '';
try {
$xml = simplexml_load_string($response->getBody());
} catch (\Exception $e) {
throw new \Exception('Error on parse reponse xml. ' . $response->getBody(), 500, $e);
}
if ($xml->code) {
return $xml->code;
}
throw new \Exception('An error has occurred: ' . $response->getBody());
}
public function testPostWithJsonContent()
{
$request = new Request();
$request->setMethod(Request::METHOD_POST);
$request->setContent('{"data":["someValue", "anotherValue"]}');
$request->getHeaders()->addHeader(new ContentType('application/json'));
$result = $this->controller->dispatch($request);
$expected = ['ApplicationFeatureApiTest\\Fixture\\CreateController', ['action' => 'index']];
$this->assertSame($expected, $result);
$expectedPost = ['data' => ['someValue', 'anotherValue']];
/** @var \Zend\Http\PhpEnvironment\Request $request */
$request = $this->controller->getRequest();
$this->assertSame($expectedPost, $request->getPost()->toArray());
}
public function testProcessPatchRequestWithZfCampusMediaTypeReturnsUpdatedConfigurationKeys()
{
$config = ['foo' => 'FOO', 'bar' => ['baz' => 'bat'], 'baz' => 'BAZ'];
$configResource = new ConfigResource($config, $this->file, $this->writer);
$controller = new ConfigController($configResource);
$controller->setPluginManager($this->plugins);
$request = new Request();
$request->setMethod('patch');
$request->setContent(json_encode(['bar' => ['baz' => 'UPDATED'], 'baz' => 'UPDATED']));
$request->getHeaders()->addHeaderLine('Content-Type', 'application/vnd.zfcampus.v1.config+json');
$request->getHeaders()->addHeaderLine('Accept', 'application/vnd.zfcampus.v1.config+json');
$controller->setRequest($request);
$result = $controller->processAction();
$this->assertInternalType('array', $result);
$expected = ['bar' => ['baz' => 'UPDATED'], 'baz' => 'UPDATED'];
$this->assertEquals($expected, $result);
}
/**
* Return an access code from an OAuth2 request callback
*/
public function validate($profile, $query)
{
$config = $this->getConfig();
// Validate the application state
$container = new Container("OAuth2_Client_{$profile}");
if ($container->state !== $query['state']) {
// @codeCoverageIgnoreStart
throw new ValidateException("Application state changed during OAuth2 authorization");
} else {
// @codeCoverageIgnoreEnd
$container->state = null;
}
// Build redirect uri
$urlPlugin = $this->getPluginManager()->get('url');
$redirectUri = $urlPlugin->fromRoute('zf-oauth2-client', array('profile' => $profile), array('force_canonical' => true));
// Exchange the authorization code for an access token
$request = new Request();
$request->setUri($config['profiles'][$profile]['endpoint']);
$request->setMethod(Request::METHOD_POST);
$request->getHeaders()->addHeaders(array('Accept' => 'application/json', 'Content-Type' => 'application/json'));
$request->setContent(Json::encode(array('grant_type' => 'authorization_code', 'client_id' => $config['profiles'][$profile]['client_id'], 'client_secret' => $config['profiles'][$profile]['secret'], 'redirect_uri' => $redirectUri, 'code' => $query['code'])));
$response = $this->getHttpClient()->send($request);
$body = Json::decode($response->getBody(), true);
if ($response->getStatusCode() !== 200) {
// @codeCoverageIgnoreStart
throw new ValidateException($body['detail'], $body['status']);
}
// @codeCoverageIgnoreEnd
// Save the access token to the session
$container->access_token = $body['access_token'];
$container->expires_in = $body['expires_in'];
$container->token_type = $body['token_type'];
$container->scope = $body['scope'];
$container->refresh_token = $body['refresh_token'];
$expires = new Datetime();
$expires = $expires->add(new DateInterval('PT' . $container->expires_in . 'S'));
$container->expires = $expires;
return $body;
}
/**
* @group 42
*/
public function testReturns400ResponseWhenBodyPartIsMissingName()
{
$request = new Request();
$request->setMethod('PUT');
$request->getHeaders()->addHeaderLine('Content-Type', 'multipart/form-data; boundary=6603ddd555b044dc9a022f3ad9281c20');
$request->setContent(file_get_contents(__DIR__ . '/TestAsset/multipart-form-data-missing-name.txt'));
$event = new MvcEvent();
$event->setRequest($request);
$event->setRouteMatch(new RouteMatch([]));
$listener = $this->listener;
$result = $listener($event);
$this->assertInstanceOf('ZF\\ApiProblem\\ApiProblemResponse', $result);
$this->assertEquals(400, $result->getStatusCode());
$details = $result->getApiProblem()->toArray();
$this->assertContains('does not contain a "name" field', $details['detail']);
}
/**
* @group 50
* @dataProvider methodsWithBodies
*/
public function testMergesHalEmbeddedPropertiesIntoTopLevelObjectWhenDecodingHalJson($method)
{
$data = ['foo' => 'bar', '_embedded' => ['bar' => ['baz' => 'bat']]];
$json = json_encode($data);
$listener = $this->listener;
$request = new Request();
$request->setMethod($method);
$request->getHeaders()->addHeaderLine('Content-Type', 'application/hal+json');
$request->setContent($json);
$event = new MvcEvent();
$event->setRequest($request);
$event->setRouteMatch(new RouteMatch([]));
$result = $listener($event);
$this->assertNull($result);
$params = $event->getParam('ZFContentNegotiationParameterData');
$expected = ['foo' => 'bar', 'bar' => ['baz' => 'bat']];
$this->assertEquals($expected, $params->getBodyParams());
}
public function testRequestCanBeCastToAString()
{
$request = new Request();
$request->setMethod(Request::METHOD_GET);
$request->setUri('/');
$request->setContent('foo=bar&bar=baz');
$this->assertEquals("GET / HTTP/1.1\r\n\r\nfoo=bar&bar=baz", $request->toString());
}
public function testDecodingMultipartFormDataWithFileRegistersFileCleanupEventListener()
{
$request = new Request();
$request->setMethod('PATCH');
$request->getHeaders()->addHeaderLine('Content-Type', 'multipart/form-data; boundary=6603ddd555b044dc9a022f3ad9281c20');
$request->setContent(file_get_contents(__DIR__ . '/TestAsset/multipart-form-data.txt'));
$target = new TestAsset\EventTarget();
$events = $this->getMock('Zend\\EventManager\\EventManagerInterface');
$events->expects($this->once())->method('attach')->with($this->equalTo('finish'), $this->equalTo(array($this->listener, 'onFinish')), $this->equalTo(1000));
$target->events = $events;
$event = new MvcEvent();
$event->setTarget($target);
$event->setRequest($request);
$event->setRouteMatch(new RouteMatch(array()));
$listener = $this->listener;
$result = $listener($event);
}
public function testAddInputFilter()
{
$inputFilter = [['name' => 'bar', 'validators' => [['name' => 'NotEmpty', 'options' => ['type' => 127]], ['name' => 'Digits']]]];
$request = new Request();
$request->setMethod('put');
$request->setContent(json_encode($inputFilter));
$request->getHeaders()->addHeaderLine('Accept', 'application/json');
$request->getHeaders()->addHeaderLine('Content-Type', 'application/json');
$module = 'InputFilter';
$controller = 'InputFilter\\V1\\Rest\\Foo\\Controller';
$params = ['name' => $module, 'controller_service_name' => $controller];
$routeMatch = new RouteMatch($params);
$routeMatch->setMatchedRouteName('zf-apigility-admin/api/module/rest-service/rest_input_filter');
$event = new MvcEvent();
$event->setRouteMatch($routeMatch);
$parameters = new ParameterDataContainer();
$parameters->setBodyParams($inputFilter);
$event->setParam('ZFContentNegotiationParameterData', $parameters);
$plugins = new PluginManager();
$plugins->setInvokableClass('bodyParams', 'ZF\\ContentNegotiation\\ControllerPlugin\\BodyParams');
$this->controller->setRequest($request);
$this->controller->setEvent($event);
$this->controller->setPluginManager($plugins);
$result = $this->controller->indexAction();
$this->assertInstanceOf('ZF\\ContentNegotiation\\ViewModel', $result);
$payload = $result->payload;
$this->assertInstanceOf('ZF\\Hal\\Entity', $payload);
$entity = $payload->entity;
$this->assertInstanceOf('ZF\\Apigility\\Admin\\Model\\InputFilterEntity', $entity);
$config = (include $this->basePath . '/module.config.php');
$validator = $config['zf-content-validation'][$controller]['input_filter'];
$expected = $config['input_filter_specs'][$validator];
$expected['input_filter_name'] = $validator;
$this->assertEquals($expected, $entity->getArrayCopy());
}
/**
* @param array $data
*
* @return string
* @throws Exception\RuntimeException
*/
private function getFile(array $data)
{
$data = array_merge(array('api_token' => $this->options->getApiToken(), 'id' => $this->options->getProjectId(), 'action' => 'export'), $data);
$fileKey = md5(json_encode($data));
if (isset($this->files[$fileKey])) {
return $this->files[$fileKey];
}
$client = new Http\Client(null, $this->options->getClient());
$request = new Http\Request();
$request->setUri($this->options->getUrl());
$request->setMethod(Http\Request::METHOD_POST);
$request->setContent(http_build_query($data));
usleep($this->options->getRequestDelay());
/** @var \Zend\Http\Response $response */
$response = $client->dispatch($request);
if (!$response->isSuccess()) {
throw new Exception\RuntimeException('Request was not successful');
}
/** @var \stdClass $content */
$content = json_decode($response->getContent());
if ($content->response->code != 200) {
throw new Exception\RuntimeException($content->response->message);
}
$this->files[$fileKey] = $content->item;
return $this->files[$fileKey];
}
public function ImportXML($id, $xml_data)
{
$zend_response = null;
$xml_response = null;
$post_data = array('xml' => $xml_data);
$post_content = http_build_query($post_data);
try {
$client = $this->getClient();
$request = new Request();
$url = $this->getEndPoint();
$request->setUri($url);
$request->setMethod(Request::METHOD_POST);
$request->setContent($post_content);
/* @var $zend_response \Zend\Http\Response */
$zend_response = $client->dispatch($request);
if ($zend_response) {
$xml_response = $zend_response->getContent();
}
} catch (\Exception $e) {
return $this->respondError($e);
}
try {
$response = $this->xml2array($xml_response);
} catch (\Exception $e) {
$response = $xml_response;
}
$this->getServiceEvent()->setResult($response);
return $response;
}
protected function getSubRequest($batchRequest, array $requestData)
{
$request = new Request();
$request->setMethod($requestData['method']);
$request->setUri($requestData['uri']);
$queryString = $request->getUri()->getQuery();
if ($queryString) {
$query = [];
parse_str($queryString, $query);
$request->setQuery(new Parameters($query));
}
$requestHeaders = [$batchRequest->getHeaders()->get('Accept'), $batchRequest->getHeaders()->get('Content-Type')];
if (isset($requestData['headers'])) {
foreach ($requestData['headers'] as $name => $value) {
$requestHeaders[] = GenericHeader::fromString($name . ': ' . $value);
}
}
$request->getHeaders()->addHeaders($requestHeaders);
if (isset($requestData['content'])) {
$request->setContent(json_encode($requestData['content']));
}
return $request;
}
/**
* @dataProvider methodsWithWhitespaceInsideBody
*/
public function testWillNotRemoveWhitespaceInsideBody($method, $content)
{
$listener = $this->listener;
$request = new Request();
$request->setMethod($method);
$request->getHeaders()->addHeaderLine('Content-Type', 'application/json');
$request->setContent($content);
$event = new MvcEvent();
$event->setRequest($request);
$event->setRouteMatch(new RouteMatch(array()));
$result = $listener($event);
$this->assertNull($result);
$params = $event->getParam('ZFContentNegotiationParameterData');
$this->assertEquals(array('foo' => 'bar foo'), $params->getBodyParams());
}
public function create($data)
{
$router = $this->serviceLocator->get('router');
$controllerLoader = $this->serviceLocator->get('controllerLoader');
foreach ($data as $key => $requestData) {
$request = new Request();
$request->setMethod($requestData['method']);
$request->setUri($requestData['uri']);
$queryString = $request->getUri()->getQuery();
if ($queryString) {
$query = [];
parse_str($queryString, $query);
$request->setQuery(new Parameters($query));
}
if (isset($requestData['headers'])) {
foreach ($requestData['headers'] as $name => $value) {
$request->getHeaders()->addHeaderLine($name, $value);
}
}
$request->getHeaders()->addHeaders([$this->request->getHeaders()->get('Accept'), $this->request->getHeaders()->get('Content-Type')]);
if (isset($requestData['content'])) {
$request->setContent(json_encode($requestData['content']));
}
$response = new Response();
$event = new MvcEvent();
$event->setRequest($request);
$event->setResponse($response);
$match = $router->match($request);
RouteListener::resolveController($match);
$contentModel = null;
if (!isset($match) || $match->getMatchedRouteName() != 'rest.' . $this->options->getManifestName()) {
$contentModel = $this->createExceptionContentModel(new Exception\RuntimeException(sprintf('%s uri is not a rest route, so is not supported by batch controller.', $requestData['uri'])), $event);
} else {
try {
$controller = $controllerLoader->get($match->getParam('controller'));
} catch (\Zend\ServiceManager\Exception\ServiceNotFoundException $exception) {
$contentModel = $this->createExceptionContentModel($exception, $event);
$response->setStatusCode(404);
}
$event->setRouteMatch($match);
$controller->setEvent($event);
if (!isset($contentModel)) {
try {
$contentModel = $controller->dispatch($request, $response);
} catch (\Exception $exception) {
$contentModel = $this->createExceptionContentModel($exception, $event);
}
}
}
$headers = [];
foreach ($response->getHeaders() as $header) {
$headers[$header->getFieldName()] = $header->getFieldValue();
}
$responseModel = new JsonModel(['status' => $response->getStatusCode(), 'headers' => $headers]);
if ($contentModel instanceof ModelInterface) {
$responseModel->addChild($contentModel, 'content');
}
$this->model->addChild($responseModel, $key);
}
return $this->model;
}
/**
* Executes a request to a given URL using injected Data Provider
*
* @param string|\Zend\Uri\HttpUri $url endpoint destination URL
* @param array|null $params request params values
* @param int $responseFormat Format of the response - needed to execute a proper parser
* @param string|null $auth Auth data login:password
* @param array|null $postData POST data
* @return mixed
* @throws \Zend\Http\Client\Exception\RuntimeException
*/
public function request($url, $params = [], $responseFormat = self::RESPONSE_IN_JSON, $auth = null, $postData = null)
{
$request = new Request();
$request->setUri($this->assembleUrl($url, $params));
// Auth data
if ($auth && !$this->getDataProvider()->getAdapter() instanceof \Zend\Http\Client\Adapter\Test) {
$this->setDataProvider($this->setDefaultDataProvider());
}
// Use POST method
if ($postData) {
$request->setMethod('POST');
$request->setContent(http_build_query($postData));
}
$client = $this->getDataProvider();
if (!is_null($this->getDaoAuth())) {
$client->setAuth($this->getDaoAuth()['username'], $this->getDaoAuth()['password'], Client::AUTH_BASIC);
}
$headers = $request->getHeaders();
$headers->addHeaders($this->getDaoHeaders());
/**
* @var \Zend\Http\Response
*/
$response = $client->dispatch($request);
if ($response->isSuccess()) {
switch ($responseFormat) {
case self::RESPONSE_IN_JSON:
$responseParsed = Json::decode($response->getBody(), Json::TYPE_ARRAY);
break;
case self::RESPONSE_IN_XML:
try {
$responseParsed = simplexml_load_string($response->getBody());
} catch (Exception $e) {
throw new Client\Exception\RuntimeException('Parsing XML from request response failed');
}
break;
case self::RESPONSE_IN_HTML:
try {
// load as HTML, supress any error and pass it to XML parser
$doc = new \DOMDocument();
$doc->recover = true;
$doc->strictErrorChecking = false;
@$doc->loadHTML($response->getBody());
$responseParsed = simplexml_load_string($doc->saveXML());
} catch (Exception $e) {
throw new Client\Exception\RuntimeException('Parsing XML from request response failed');
}
break;
case self::RESPONSE_AS_IS:
$responseParsed = $response;
break;
default:
throw new Client\Exception\RuntimeException('Parser for request response not found.');
break;
}
return $responseParsed;
} else {
throw new Client\Exception\RuntimeException('Request failed with status: ' . $response->renderStatusLine() . ' ' . $response->getBody(), $response->getStatusCode());
}
}
$loader->register();
/*
GET URI 1.1
HEADERS Content-Type: text/html
BODY -> Conteudo
*/
use Zend\Http\Request;
// Request GET
//$request = new Request();
//$request->setMethod(Request::METHOD_GET);
//$request->setUri("http://google.com");
//$request->setContent("Conteúdo da nossa request");
//
//echo $request->toString();
// POST
//$request = new Request();
//$request->setMethod(Request::METHOD_POST);
//$request->getPost()->set('nome','Wesley');
//$request->getPost()->set('x','10');
//$request->setUri("http://google.com");
//$request->setContent($request->getPost()->toString());
//
//echo $request->toString();
$request = new Request();
$request->setMethod(Request::METHOD_POST);
$request->getPost()->set('nome', 'Wesley');
$request->getHeaders()->addHeaders(array('headerX' => 10, 'headerY' => 20));
$request->getHeaders()->addHeaderLine('Content-Type: text/html');
$request->setUri("http://google.com");
$request->setContent($request->getPost()->toString());
echo $request->toString();
/**
* Call an api method
*
* @param $method
* @param $params
* @return mixed
* @throws \Exception
*/
public function call($method, $params)
{
$params['apikey'] = $this->getApiKey();
$params = json_encode($params);
$client = $this->getClient();
$uri = $this->getBaseUri() . $method . '.json';
$headers = new Headers();
$headers->addHeaderLine('Accept-Encoding', 'identity');
$headers->addHeaderLine('Content-Type', 'application/json');
$headers->addHeaderLine('Accept', '*/*');
$request = new Request();
$request->setHeaders($headers);
$request->setUri($uri);
$request->setMethod('POST');
$request->setContent($params);
$response = $client->dispatch($request);
if ($response->isSuccess()) {
return json_decode($response->getContent(), true);
} else {
/*@TODO throw a more useful exception*/
throw new \Exception('Request Failed');
}
}
/**
* HTTP POST METHOD (static)
*
* @param string $url
* @param array $params
* @param array $headers
* @param mixed $body
* @throws Exception\InvalidArgumentException
* @return Response|bool
*/
public static function post($url, $params, $headers = array(), $body = null)
{
if (empty($url)) {
return false;
}
$request = new Request();
$request->setUri($url);
$request->setMethod(Request::METHOD_POST);
if (!empty($params) && is_array($params)) {
$request->getPost()->fromArray($params);
} else {
throw new Exception\InvalidArgumentException('The array of post parameters is empty');
}
if (!isset($headers['Content-Type'])) {
$headers['Content-Type'] = Client::ENC_URLENCODED;
}
if (!empty($headers) && is_array($headers)) {
$request->getHeaders()->addHeaders($headers);
}
if (!empty($body)) {
$request->setContent($body);
}
return static::getStaticClient()->send($request);
}
/**
* @dataProvider methodsWithStringContent
*
* @param string $method
* @param string $data
* @param string $key
*/
public function testStringContentIsParsedCorrectlyToAnArray($method, $data, $key)
{
$listener = $this->listener;
$request = new Request();
$request->setMethod($method);
$request->setContent($data);
$event = new MvcEvent();
$event->setRequest($request);
$event->setRouteMatch($this->createRouteMatch([]));
$result = $listener($event);
$this->assertNull($result);
/** @var \ZF\ContentNegotiation\ParameterDataContainer $params */
$params = $event->getParam('ZFContentNegotiationParameterData');
$array = $params->getBodyParams();
$this->assertArrayHasKey($key, $array);
$this->assertSame('', $array[$key]);
}
