/**
  * @param string $url
  * @param mixed[]|null $body
  * @return \SlevomatZboziApi\Response\ZboziApiResponse
  */
 public function sendPostRequest($url, array $body = null)
 {
     TypeValidator::checkString($url);
     $options = ['allow_redirects' => false, 'verify' => true, 'decode_content' => true, 'expect' => false, 'timeout' => $this->timeoutInSeconds];
     $request = $this->client->createRequest('POST', $url, $options);
     $request->setHeaders([static::HEADER_PARTNER_TOKEN => $this->partnerToken, static::HEADER_API_SECRET => $this->apiSecret]);
     if ($body !== null) {
         $request->setBody(\GuzzleHttp\Stream\Stream::factory(json_encode($body)));
     }
     try {
         try {
             $response = $this->client->send($request);
             $this->log($request, $response);
             return $this->getZboziApiResponse($response);
         } catch (\GuzzleHttp\Exception\RequestException $e) {
             $response = $e->getResponse();
             $this->log($request, $response);
             if ($response !== null) {
                 return $this->getZboziApiResponse($response);
             }
             throw new \SlevomatZboziApi\Request\ConnectionErrorException('Connection to Slevomat API failed.', $e->getCode(), $e);
         }
     } catch (\GuzzleHttp\Exception\ParseException $e) {
         $this->log($request, isset($response) ? $response : null, true);
         throw new \SlevomatZboziApi\Response\ResponseErrorException('Slevomat API invalid response: invalid JSON data.', $e->getCode(), $e);
     }
 }
Пример #2
0
 public function callApi($call, $method = 'GET', array $options = [])
 {
     $time = microtime(true);
     $request = $this->_guzzle->createRequest($method, $this->_baseUri . '/' . $call, $options);
     if ($this->_headers) {
         foreach ($this->_headers as $header => $value) {
             $request->addHeader($header, $value);
         }
     }
     if (!$this->isBatchOpen()) {
         try {
             return $this->_processResponse($this->_guzzle->send($request), $time);
         } catch (RequestException $e) {
             $response = $e->getResponse();
             if ($response) {
                 return $this->_processResponse($response, $time);
             } else {
                 throw $e;
             }
         }
     }
     $batchId = uniqid($method, true);
     $request->addHeader('X-Batch-ID', $batchId);
     $apiResult = new ApiResult();
     $this->_batch[] = $request;
     $this->_results[$batchId] = $apiResult;
     return $apiResult;
 }
Пример #3
0
 public function testOnlyResponse()
 {
     $request = $this->guzzleHttpClient->createRequest('GET', 'http://petstore.swagger.io/v2/pet/findByStatus');
     $request->addHeader('Accept', 'application/json');
     $response = $this->guzzleHttpClient->send($request);
     $this->assertResponseMatch($response, self::$schemaManager, '/v2/pet/findByStatus', 'get');
 }
 /**
  * {@inheritdoc}
  */
 public function fetch(FeedInterface $feed)
 {
     $request = $this->httpClient->createRequest('GET', $feed->getUrl());
     $feed->source_string = FALSE;
     // Generate conditional GET headers.
     if ($feed->getEtag()) {
         $request->addHeader('If-None-Match', $feed->getEtag());
     }
     if ($feed->getLastModified()) {
         $request->addHeader('If-Modified-Since', gmdate(DateTimePlus::RFC7231, $feed->getLastModified()));
     }
     try {
         $response = $this->httpClient->send($request);
         // In case of a 304 Not Modified, there is no new content, so return
         // FALSE.
         if ($response->getStatusCode() == 304) {
             return FALSE;
         }
         $feed->source_string = $response->getBody(TRUE);
         $feed->setEtag($response->getHeader('ETag'));
         $feed->setLastModified(strtotime($response->getHeader('Last-Modified')));
         $feed->http_headers = $response->getHeaders();
         // Update the feed URL in case of a 301 redirect.
         if ($response->getEffectiveUrl() != $feed->getUrl()) {
             $feed->setUrl($response->getEffectiveUrl());
         }
         return TRUE;
     } catch (RequestException $e) {
         $this->logger->warning('The feed from %site seems to be broken because of error "%error".', array('%site' => $feed->label(), '%error' => $e->getMessage()));
         drupal_set_message(t('The feed from %site seems to be broken because of error "%error".', array('%site' => $feed->label(), '%error' => $e->getMessage())), 'warning');
         return FALSE;
     }
 }
 public function testFetchPetBodyMatchDefinition()
 {
     $request = $this->guzzleHttpClient->createRequest('GET', 'http://petstore.swagger.io/v2/pet/findByStatus');
     $request->addHeader('Accept', 'application/json');
     $response = $this->guzzleHttpClient->send($request);
     $responseBody = $response->json(['object' => true]);
     $this->assertResponseBodyMatch($responseBody, self::$schemaManager, '/v2/pet/findByStatus', 'get', 200);
 }
 /**
  * Converts a PSR request into a Guzzle request.
  *
  * @param RequestInterface $request
  *
  * @return GuzzleRequest
  */
 private function createRequest(RequestInterface $request)
 {
     $options = ['exceptions' => false, 'allow_redirects' => false];
     $options['version'] = $request->getProtocolVersion();
     $options['headers'] = $request->getHeaders();
     $options['body'] = (string) $request->getBody();
     return $this->client->createRequest($request->getMethod(), (string) $request->getUri(), $options);
 }
Пример #7
0
 /**
  * @param string $method
  * @param string $path
  * @param array $options
  *
  * @return array
  */
 public function sendRequest($method, $path, array $options = [])
 {
     try {
         $response = $this->handler->send($this->handler->createRequest($method, $path, $options));
     } catch (ClientException $ex) {
         $response = $ex->getResponse();
     }
     return $response->json();
 }
Пример #8
0
 private function sendRequest()
 {
     $url = self::ApiUrl . '/' . $this->request;
     $request = $this->client->createRequest('GET', $url);
     $request->addHeader('Content-Type', 'application/json');
     $response = $this->client->send($request);
     $data = $response->json();
     return new Response($data);
 }
Пример #9
0
 /**
  * {@inheritdoc}
  */
 public function queryCircle($url, $query_args = [], $method = 'GET', $request_options = [])
 {
     if (!isset($query_args['circle-token'])) {
         throw new \InvalidArgumentException('The circle-token is required for all endpoints.');
     }
     $url .= '?' . http_build_query($query_args);
     $request = $this->httpClient->createRequest($method, $url, $request_options);
     $request->addHeaders(['Accept' => 'application/json']);
     return $this->httpClient->send($request)->json();
 }
Пример #10
0
 /**
  * {@inheritdoc }
  */
 public function post($url, $body, array $files = array())
 {
     $request = $this->httpClient->createRequest('POST', $url, ['body' => $body]);
     /** @var PostBodyInterface $postBody */
     $postBody = $request->getBody();
     foreach ($files as $key => $filePath) {
         $file = $this->postFileFactory->create($key, $filePath);
         $postBody->addFile($file);
     }
     $response = $this->httpClient->send($request);
     return $response;
 }
Пример #11
0
 /**
  * @param string $endpoint
  * @param string $content
  * @param array $headers
  * @param array $files
  * @return Response
  */
 public function send($endpoint, $content, array $headers = array(), array $files = array())
 {
     $request = $this->client->createRequest('POST', $endpoint, array('body' => $content, 'exceptions' => false, 'headers' => $headers));
     $body = new PostBody();
     if ($files && $request instanceof RequestInterface) {
         foreach ($files as $name => $path) {
             $body->addFile(new PostFile($name, fopen($path, 'r')));
         }
     }
     $request->setBody($body);
     $response = $this->client->send($request);
     return new Response($response->getStatusCode(), $response->getBody());
 }
Пример #12
0
 /**
  * {@inheritdoc}
  */
 public function request($method, $url, $secret, array $params = [])
 {
     $options = ['auth' => [$secret, ''], 'connect_timeout' => 10, 'timeout' => 30, 'verify' => true];
     if ('GET' !== $method) {
         $options['body'] = $params;
     }
     $request = $this->client->createRequest($method, $url, $options);
     try {
         $rawResponse = $this->client->send($request);
     } catch (RequestException $e) {
         $rawResponse = $this->handleException($e);
     }
     return new Response($rawResponse->getStatusCode(), $rawResponse->getBody());
 }
Пример #13
0
 /**
  * @param RequestInterface $request
  *
  * @return \GuzzleHttp\Message\RequestInterface
  */
 protected function createGuzzleRequestFromRequest(RequestInterface $request)
 {
     $headers = array();
     foreach ($request->getHeaders() as $headerName => $headerValue) {
         $headers[$headerName] = $headerValue[0];
     }
     $headers['X-Forwarded-For'] = $request->getClientIp();
     $headers['X-Forwarded-Proto'] = $request->getScheme();
     if (isset($headers['cookie'])) {
         unset($headers['cookie']);
     }
     // see http://guzzle.readthedocs.org/en/latest/clients.html#request-options
     $guzzleRequest = $this->client->createRequest($request->getMethod(), $request->getUri(), array('headers' => $headers, 'body' => $request->getBody(), 'query' => $request->getQueryParams(), 'cookies' => $request->getCookies(), 'exceptions' => false, 'decode_content' => true));
     return $guzzleRequest;
 }
Пример #14
0
 function it_should_post_an_url(ClientInterface $handler, RequestInterface $request, ResponseInterface $response)
 {
     $options = ['body' => 'foo'];
     $handler->createRequest('POST', 'foo', $options)->willReturn($request);
     $handler->send($request)->shouldBeCalled();
     $handler->send($request)->willReturn($response);
     $this->post('foo', $options);
 }
Пример #15
0
 /**
  * @param string $method
  * @param array  $payload
  *
  * @return RequestInterface
  */
 private function createRequest($method, array $payload)
 {
     $request = $this->client->createRequest('POST');
     $request->setUrl(self::API_BASE_URL . $method);
     $body = new PostBody();
     $body->replaceFields($payload);
     $request->setBody($body);
     return $request;
 }
Пример #16
0
 /**
  * Send a POST request to activeCollab
  * @param $path
  * @param array $data
  * @return object
  * @throws Exception\ApiException
  * @throws Exception\AuthenticationFailedException
  */
 public function post($path, array $data = array())
 {
     // Apparently the activeCollab API requires this
     if (!isset($data['submitted'])) {
         $data['submitted'] = 'submitted';
     }
     $request = $this->client->createRequest('POST', null, ['body' => $data]);
     $request->setQuery(['path_info' => $path]);
     return $this->send($request);
 }
 /**
  * Run request to Restoration Media
  */
 public function send()
 {
     $request = $this->client->createRequest('GET', $this->getBuiltUrl());
     $request->setHeader('User-Agent', 'github.com/caseyw/restorationmedia_php');
     $this->response = $this->client->send($request);
     /*
      * Restoration Media doesn't actually use HTTP Status Codes. I don't know why.
      */
     return 'success.' == $this->response->xml() ? true : false;
 }
Пример #18
0
 /**
  * Sends HTTP request to specific path with body wrapped by field.
  *
  * @param string $method
  * @param string $path
  * @param string $field
  * @param TableNode $table
  *
  * @When /^(?:I )?send a (PUT|PATCH|POST) request to path "([^"]+)" with field (\w+)$/
  */
 public function iSendARequestWithField($method, $path, $field, TableNode $table = null)
 {
     $url = $this->getUrlFromPath($path, $method);
     $request = $this->client->createRequest($method, $url, ['headers' => $this->getHeadersBag()->all()]);
     if (null !== $table) {
         $body = new PostBody();
         $body->replaceFields([$field => $table->getRowsHash()]);
         $request->setBody($body);
     }
     $this->send($request);
 }
 private function createGuzzleRequest(Psr7Request $psrRequest, array $options)
 {
     $ringConfig = [];
     // Remove unsupported options.
     foreach (array_keys($options) as $key) {
         if (!isset(self::$validOptions[$key])) {
             unset($options[$key]);
         }
     }
     // Handle delay option.
     if (isset($options['delay'])) {
         $ringConfig['delay'] = $options['delay'];
         unset($options['delay']);
     }
     // Prepare sink option.
     if (isset($options['sink'])) {
         $ringConfig['save_to'] = $options['sink'] instanceof Psr7StreamInterface ? new GuzzleStream($options['sink']) : $options['sink'];
         unset($options['sink']);
     }
     // Ensure that all requests are async and lazy like Guzzle 6.
     $options['future'] = 'lazy';
     // Create the Guzzle 5 request from the provided PSR7 request.
     $request = $this->client->createRequest($psrRequest->getMethod(), $psrRequest->getUri(), $options);
     // For the request body, adapt the PSR stream to a Guzzle stream.
     $body = $psrRequest->getBody();
     if ($body->getSize() === 0) {
         $request->setBody(null);
     } else {
         $request->setBody(new GuzzleStream($body));
     }
     $request->setHeaders($psrRequest->getHeaders());
     $request->setHeader('User-Agent', 'aws-sdk-php/' . Sdk::VERSION . ' ' . Client::getDefaultUserAgent());
     // Make sure the delay is configured, if provided.
     if ($ringConfig) {
         foreach ($ringConfig as $k => $v) {
             $request->getConfig()->set($k, $v);
         }
     }
     return $request;
 }
Пример #20
0
 /**
  * Send HTTP request
  * @param string $method POST|GET
  * @param string $url http URL
  * @param array $options query options. Query values goes under 'body' key.
  * Example:
  * $options = [
  *     'query' => [
  *         'access_token' => 'foobar',
  *     ],
  *     'body' => [
  *         'param1' => 'value1',
  *         'param2' => 'value2',
  *     ]
  * ]
  * @return array
  */
 public function sendRequest($method, $url, array $options = [])
 {
     $result = [];
     try {
         $response = $this->client->send($this->client->createRequest($method, $url, $options));
         $result = $response->json();
     } catch (ClientException $e) {
         if ($e->getCode() == 400) {
             throw new Exception\InvalidData('Data validation failed', 400, $e, $e->getResponse()->json());
         } elseif ($e->getCode() == 403) {
             throw new Exception\InvalidApiKey('Access forbidden. Invalid API key.', 403, $e, $e->getResponse()->getBody());
         } elseif ($e->getCode() == 500) {
             throw new Exception\ServerError('Error occurred on server side while handling request', 500, $e, $e->getResponse()->getBody());
         } elseif ($e->getCode() == 504) {
             throw new Exception\Timeout('Request timeout', 504, $e, $e->getResponse()->getBody());
         } else {
             throw new Exception\UnexpectedResponse('Unexpected error occurred', $e->getCode(), $e, $e->getResponse()->getBody());
         }
     } catch (\Exception $e) {
         throw new Exception\UnexpectedError('Unexpected error occurred', 0, $e);
     }
     return $result;
 }
Пример #21
0
 /**
  * Sends HTTP request to specific URL with form data from PyString.
  *
  * @param string       $method request method
  * @param string       $url    relative url
  * @param PyStringNode $body   request body
  *
  * @When /^(?:I )?send a ([A-Z]+) request to "([^"]+)" with form data:$/
  */
 public function iSendARequestWithFormData($method, $url, PyStringNode $body)
 {
     $url = $this->prepareUrl($url);
     $body = $this->replacePlaceHolder(trim($body));
     $fields = array();
     parse_str(implode('&', explode("\n", $body)), $fields);
     $this->request = $this->client->createRequest($method, $url);
     /** @var \GuzzleHttp\Post\PostBodyInterface $requestBody */
     $requestBody = $this->request->getBody();
     foreach ($fields as $key => $value) {
         $requestBody->setField($key, $value);
     }
     $this->sendRequest();
 }
 /**
  * Create a Guzzle5 request object
  *
  * @param RequestInterface $request
  * @param bool $async
  * @return Request
  */
 private function createRequest(RequestInterface $request, $async = false)
 {
     $body = Stream::factory($request->getBody());
     $uri = (string) $request->getUri();
     $headers = $request->getHeaders();
     // fixes issue with host getting applied twice
     if (isset($headers['Host'])) {
         unset($headers['Host']);
     }
     $options = $async ? ['future' => true] : [];
     $request = $this->client->createRequest($request->getMethod(), $uri, $options);
     $request->setBody($body);
     $request->setHeaders(array_merge($request->getHeaders(), $headers));
     return $request;
 }
Пример #23
0
 private function createGuzzleRequest(Psr7Request $psrRequest, array $options)
 {
     $ringConfig = [];
     $statsCallback = isset($options['http_stats_receiver']) ? $options['http_stats_receiver'] : null;
     unset($options['http_stats_receiver']);
     // Remove unsupported options.
     foreach (array_keys($options) as $key) {
         if (!isset(self::$validOptions[$key])) {
             unset($options[$key]);
         }
     }
     // Handle delay option.
     if (isset($options['delay'])) {
         $ringConfig['delay'] = $options['delay'];
         unset($options['delay']);
     }
     // Prepare sink option.
     if (isset($options['sink'])) {
         $ringConfig['save_to'] = $options['sink'] instanceof Psr7StreamInterface ? new GuzzleStream($options['sink']) : $options['sink'];
         unset($options['sink']);
     }
     // Ensure that all requests are async and lazy like Guzzle 6.
     $options['future'] = 'lazy';
     // Create the Guzzle 5 request from the provided PSR7 request.
     $request = $this->client->createRequest($psrRequest->getMethod(), $psrRequest->getUri(), $options);
     if (is_callable($statsCallback)) {
         $request->getEmitter()->on('end', function (EndEvent $event) use($statsCallback) {
             $statsCallback($event->getTransferInfo());
         });
     }
     // For the request body, adapt the PSR stream to a Guzzle stream.
     $body = $psrRequest->getBody();
     if ($body->getSize() === 0) {
         $request->setBody(null);
     } else {
         $request->setBody(new GuzzleStream($body));
     }
     $request->setHeaders($psrRequest->getHeaders());
     $request->setHeader('User-Agent', $request->getHeader('User-Agent') . ' ' . Client::getDefaultUserAgent());
     // Make sure the delay is configured, if provided.
     if ($ringConfig) {
         foreach ($ringConfig as $k => $v) {
             $request->getConfig()->set($k, $v);
         }
     }
     return $request;
 }
Пример #24
0
 /**
  * calls every given url with the specific shop cookie
  *
  * @param string[] $urls
  * @param integer $shopId
  */
 public function callUrls($urls, $shopId)
 {
     $shop = $this->getShopDataById($shopId);
     $guzzleConfig = [];
     if (!empty($shop["main_id"])) {
         //is not the main shop call url without shop cookie encoded in it
         $guzzleConfig['cookies'] = ['shop' => $shopId];
     }
     foreach ($urls as $url) {
         $request = $this->guzzleClient->createRequest('GET', $url, $guzzleConfig);
         try {
             $this->guzzleClient->send($request);
         } catch (\Exception $e) {
             $this->logger->error("Warm up http-cache error with shopId " . $shopId . " " . $e->getMessage());
         }
     }
 }
Пример #25
0
 /**
  * Method returns the response for the requested resource.
  *
  * @param string $pURL
  * @param array  $pOptions
  *
  * @return mixed
  */
 protected function requestResource($pURL, array $pOptions)
 {
     $options = array_replace_recursive($this->settings['defaults'], $pOptions);
     $format = $options['format'];
     $method = $options['method'];
     $this->setHeaders($options);
     $parameters['headers'] = $this->headers;
     if (isset($options['body'])) {
         $parameters['body'] = $this->formatBody($options);
     }
     $request = $this->client->createRequest($method, $pURL, $parameters);
     try {
         $response = $this->client->send($request);
         $this->event->fire('forrest.response', [$request, $response]);
         return $this->responseFormat($response, $format);
     } catch (RequestException $e) {
         $this->assignExceptions($e);
     }
     return '';
 }
Пример #26
0
 /**
  * Creates a request.
  *
  * @param \Ivory\HttpAdapter\Message\InternalRequestInterface $internalRequest The internal request.
  * @param callable|null                                       $success         The success callable.
  * @param callable|null                                       $error           The error callable.
  *
  * @return \GuzzleHttp\Message\RequestInterface The request.
  */
 private function createRequest(InternalRequestInterface $internalRequest, $success = null, $error = null)
 {
     $request = $this->client->createRequest($internalRequest->getMethod(), (string) $internalRequest->getUrl(), array('exceptions' => false, 'allow_redirects' => false, 'timeout' => $this->getConfiguration()->getTimeout(), 'connect_timeout' => $this->getConfiguration()->getTimeout(), 'version' => $internalRequest->getProtocolVersion(), 'headers' => $this->prepareHeaders($internalRequest), 'body' => $this->prepareContent($internalRequest)));
     if (is_callable($success)) {
         $messageFactory = $this->getConfiguration()->getMessageFactory();
         $request->getEmitter()->on('complete', function (CompleteEvent $event) use($success, $internalRequest, $messageFactory) {
             $response = $messageFactory->createResponse((int) $event->getResponse()->getStatusCode(), $event->getResponse()->getReasonPhrase(), $event->getResponse()->getProtocolVersion(), $event->getResponse()->getHeaders(), BodyNormalizer::normalize(function () use($event) {
                 return new GuzzleHttpStream($event->getResponse()->getBody());
             }, $internalRequest->getMethod()));
             $response->setParameter('request', $internalRequest);
             call_user_func($success, $response);
         });
     }
     if (is_callable($error)) {
         $httpAdapterName = $this->getName();
         $request->getEmitter()->on('error', function (ErrorEvent $event) use($error, $internalRequest, $httpAdapterName) {
             $exception = HttpAdapterException::cannotFetchUrl($event->getException()->getRequest()->getUrl(), $httpAdapterName, $event->getException()->getMessage());
             $exception->setRequest($internalRequest);
             call_user_func($error, $exception);
         });
     }
     return $request;
 }
Пример #27
0
 public function post($urlPath, array $parameters = [], $body)
 {
     $request = $this->httpClient->createRequest('POST', array(), array('body' => $body));
     $url = rtrim($this->getBaseUrl(), '/') . '/' . trim($urlPath, '/');
     $request->setUrl($url);
     // Set the API key in a header instead of a URL parameter, so it will
     // not accidentally end up in log messages.
     $request->setHeader('X-IZI-API-KEY', $this->apiKey);
     // Add compression.
     $this->addCompression($request);
     // For some strange reason, for the first post request (reviews)
     // we need to add the api-key to the url.
     // It might change, so when that is happening, you are free to alter this here.
     // Mind to test the posting of reviews again if you change it.
     $parameters['api_key'] = $this->apiKey;
     $parameters['version'] = ApiInterface::VERSION;
     $request->getQuery()->replace($parameters);
     $request->getQuery()->setAggregator(static::getGuzzleQueryAggregator());
     $pre_request_event = new PreRequest($request);
     $this->eventDispatcher->dispatch(IziTravelEvents::PRE_REQUEST, $pre_request_event);
     try {
         $response = $this->httpClient->send($request);
         $post_response_event = new PostResponse($response);
         $this->eventDispatcher->dispatch(IziTravelEvents::POST_RESPONSE, $post_response_event);
         $json = $response->getBody()->getContents();
     } catch (\Exception $e) {
         throw new HttpRequestException(sprintf('An exception was thrown during the API request to %s: %s', $request->getUrl(), $e->getMessage()), 0, $e);
     }
     $responseData = json_decode($json);
     if (json_last_error()) {
         throw new HttpRequestException(sprintf('The request to %s did not return valid JSON.', $request->getUrl()));
     } elseif (is_array($responseData) && isset($responseData['error'])) {
         throw new ErrorResponseException($responseData['error'], $responseData['code']);
     } else {
         return $json;
     }
 }
Пример #28
0
 /**
  * @param string      $method
  * @param array       $data
  * @param string|null $token
  *
  * @throws SlackException
  *
  * @return array
  */
 private function doSend($method, array $data, $token = null)
 {
     try {
         $data['token'] = $token ?: $this->token;
         $this->eventDispatcher->dispatch(self::EVENT_REQUEST, new RequestEvent($data));
         $request = $this->client->createRequest('POST', self::API_BASE_URL . $method);
         $body = new PostBody();
         $body->replaceFields($data);
         $request->setBody($body);
         $response = $this->client->send($request);
     } catch (\Exception $e) {
         throw new SlackException('Failed to send data to the Slack API', null, $e);
     }
     try {
         $responseData = json_decode($response->getBody(), true);
         if (!is_array($responseData)) {
             throw new \Exception(sprintf('Expected JSON-decoded response data to be of type "array", got "%s"', gettype($responseData)));
         }
         $this->eventDispatcher->dispatch(self::EVENT_RESPONSE, new ResponseEvent($responseData));
         return $responseData;
     } catch (\Exception $e) {
         throw new SlackException('Failed to process response from the Slack API', null, $e);
     }
 }
Пример #29
0
    /**
     * @param Schedule $schedule
     * @return \GuzzleHttp\Message\RequestInterface
     */
    public function buildSearchRequest(Schedule $schedule)
    {
        $rawXmlRequest = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<env:Envelope
    xmlns:env="http://www.w3.org/2003/05/soap-envelope"
    xmlns:ns1="http://tempuri.org/"
    xmlns:ns2="http://www.w3.org/2005/08/addressing">
    <env:Header>
        <ns2:Action env:mustUnderstand="true">http://tempuri.org/IWSVentaOnline/ObtenerTarifas</ns2:Action>
        <ns2:To env:mustUnderstand="true">{$this->config["url"]}</ns2:To>
    </env:Header>
    <env:Body>
        <ns1:ObtenerTarifas>
            <ns1:strOrigen>{$schedule->getFrom()}</ns1:strOrigen>
            <ns1:strDestino>{$schedule->getTo()}</ns1:strDestino>
            <ns1:strFecha>{$schedule->getDatetime()->format('Y-m-d')}</ns1:strFecha>
        </ns1:ObtenerTarifas>
    </env:Body>
</env:Envelope>
XML;
        $header = 'application/soap+xml; charset=utf-8; action="http://tempuri.org/IWSVentaOnline/ObtenerTarifas"';
        return $this->httpClient->createRequest('POST', $this->config['endpoint'], ['body' => $rawXmlRequest, 'headers' => ['Content-type' => $header]]);
    }
Пример #30
0
 public function it_returns_a_resource(ClientInterface $mockedClient, StorageInterface $mockedStorage, RequestInterface $mockedRequest, ResponseInterface $mockedResponse)
 {
     $mockedClient->createRequest(Argument::type('string'), Argument::type('string'), Argument::type('array'))->willReturn($mockedRequest);
     $mockedClient->send(Argument::any())->willReturn($mockedResponse);
     $mockedResponse->json()->shouldBeCalled()->willReturn('jsonResource');
     $mockedResponse->xml()->shouldBeCalled()->willReturn('xmlResource');
     $mockedStorage->getTokenData()->willReturn(['access_token' => 'abc', 'instance_url' => 'def', 'token_type' => 'bearer']);
     $this->request('uri', [])->shouldReturn('jsonResource');
     $this->request('uri', ['format' => 'xml'])->shouldReturn('xmlResource');
 }