PHP RequestInterface::getBody方法代码示例

 /**
  * @param RequestInterface|ResponseInterface $message
  * @return string
  */
 protected function formatBody($message)
 {
     $header = $message->getHeader('Content-Type');
     if (JsonStringFormatter::isJsonHeader($header)) {
         $formatter = new JsonStringFormatter();
         return $formatter->format($message->getBody());
     } elseif (XmlStringFormatter::isXmlHeader($header)) {
         $formatter = new XmlStringFormatter();
         return $formatter->format($message->getBody());
     }
     $factory = new StringFactoryFormatter();
     return $factory->format($message->getBody());
 }

 public function visit(CommandInterface $command, RequestInterface $request, Parameter $param, array $context)
 {
     $name = urlencode($param->formName);
     $value = urlencode($command[$param->getName()]);
     $content = Stream::factory($param->filter($value));
     if ($request->getBody() === null) {
         $request->setBody(Stream::factory(""));
     }
     $queryChar = '&';
     if ($request->getBody()->__toString() == '') {
         $queryChar = '';
     }
     $request->getBody()->write($queryChar . $name . "=" . $content);
 }

 /**
  * Calculate signature for request
  *
  * @param RequestInterface $request Request to generate a signature for
  *
  * @return string
  */
 public function getSignature(RequestInterface $request)
 {
     // For POST|PUT set the JSON body string as the params
     if ($request->getMethod() == 'POST' || $request->getMethod() == 'PUT') {
         $params = $request->getBody()->__toString();
         /**
          * If you don't seek() back to the beginning then attempting to
          * send a JSON body > 1MB will probably fail.
          *
          * @link http://stackoverflow.com/q/32359664/99071
          * @link https://groups.google.com/forum/#!topic/guzzle/vkF5druf6AY
          */
         $request->getBody()->seek(0);
         // Make sure to remove any other query params
         $request->setQuery([]);
     } else {
         $params = Query::fromString($request->getQuery(), Query::RFC1738)->toArray();
         $params = $this->prepareParameters($params);
         // Re-Set the query to the properly ordered query string
         $request->setQuery($params);
         $request->getQuery()->setEncodingType(Query::RFC1738);
     }
     $baseString = $this->createBaseString($request, $params);
     return base64_encode($this->sign_HMAC_SHA256($baseString));
 }

 /**
  * @inheritDoc
  */
 public function format(RequestInterface $request, ResponseInterface $response = null, \Exception $error = null, array $customData = [])
 {
     if (in_array($request->getPath(), $this->paths)) {
         $customData = array_merge(['url' => $this->mask((string) $request->getUrl()), 'resource' => $this->mask($request->getResource()), 'request' => $this->mask((string) $request), 'response' => $this->mask((string) $response), 'res_body' => $response ? $this->mask((string) $response) : 'NULL', 'req_body' => $this->mask((string) $request->getBody())], $customData);
     }
     return parent::format($request, $response, $error, $customData);
 }

 /**
  * Creates a Ring request from a request object.
  *
  * This function does not hook up the "then" and "progress" events that
  * would be required for actually sending a Guzzle request through a
  * RingPHP handler.
  *
  * @param RequestInterface $request Request to convert.
  *
  * @return array Converted Guzzle Ring request.
  */
 public static function createRingRequest(RequestInterface $request)
 {
     $options = $request->getConfig()->toArray();
     $url = $request->getUrl();
     // No need to calculate the query string twice (in URL and query).
     $qs = ($pos = strpos($url, '?')) ? substr($url, $pos + 1) : null;
     return ['scheme' => $request->getScheme(), 'http_method' => $request->getMethod(), 'url' => $url, 'uri' => $request->getPath(), 'headers' => $request->getHeaders(), 'body' => $request->getBody(), 'version' => $request->getProtocolVersion(), 'client' => $options, 'query_string' => $qs, 'future' => isset($options['future']) ? $options['future'] : false];
 }

 protected function assertRequestHasPostParameter($parameterName, $expectedValue, RequestInterface $request)
 {
     /** @var PostBody $requestBody */
     $requestBody = $request->getBody();
     $this->assertNotEmpty($requestBody);
     $this->assertInstanceOf(PostBody::class, $requestBody);
     $actualValue = $requestBody->getField($parameterName);
     $this->assertNotNull($actualValue, "The request should have the post body parameter '{$parameterName}'");
     $this->assertEquals($expectedValue, $actualValue);
 }

 /**
  * {@inheritdoc}
  * Replaces the ewayCardNumber field in the body with "X"s.
  */
 public function format(RequestInterface $request, ResponseInterface $response = null, \Exception $error = null, array $customData = array())
 {
     $body = $request->getBody()->__toString();
     $newBody = preg_replace_callback('/<ewayCardNumber>(.*?)<\\/ewayCardNumber>/', function ($matches) {
         $privateNumber = str_repeat('X', strlen($matches[1]) - 4) . substr($matches[1], -4);
         return '<ewayCardNumber modified>' . $privateNumber . '</ewayCardNumber>';
     }, $body);
     $newRequest = clone $request;
     $newRequest->setBody(Stream::factory($newBody));
     $request->setBody(Stream::factory($body));
     return parent::format($newRequest, $response, $error, $customData);
 }

 public function visit(GuzzleCommandInterface $command, RequestInterface $request, Parameter $param, array $context)
 {
     $body = $request->getBody();
     if (!$body instanceof PostBodyInterface) {
         throw new \RuntimeException('Must be a POST body interface');
     }
     $value = $param->filter($command[$param->getName()]);
     if (!$value instanceof PostFileInterface) {
         $value = new PostFile($param->getWireName(), $value);
     }
     $body->addFile($value);
 }

 /**
  * 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->getClient()->createRequest($method, $url);
     /** @var \GuzzleHttp\Post\PostBodyInterface $requestBody */
     $requestBody = $this->request->getBody();
     foreach ($fields as $key => $value) {
         $requestBody->setField($key, $value);
     }
     $this->sendRequest();
 }

 public function after(CommandInterface $command, RequestInterface $request, Operation $operation, array $context)
 {
     $additional = $operation->getAdditionalParameters();
     if ($additional && $additional->getLocation() == $this->locationName) {
         $body = $request->getBody();
         if (!$body instanceof PostBodyInterface) {
             throw new \RuntimeException('Must be a POST body interface');
         }
         foreach ($command->toArray() as $key => $value) {
             if (!$operation->hasParam($key)) {
                 $body->setField($key, $this->prepareValue($value, $additional));
             }
         }
     }
 }

 public function signRequest(RequestInterface $request, CredentialsInterface $credentials)
 {
     /** @var PostBodyInterface $body */
     $body = $request->getBody();
     $body->setField('Timestamp', gmdate('c'));
     $body->setField('SignatureVersion', '2');
     $body->setField('SignatureMethod', 'HmacSHA256');
     $body->setField('AWSAccessKeyId', $credentials->getAccessKeyId());
     if ($token = $credentials->getSecurityToken()) {
         $body->setField('SecurityToken', $token);
     }
     // build string to sign
     $sign = $request->getMethod() . "\n" . $request->getHost() . "\n" . '/' . "\n" . $this->getCanonicalizedParameterString($body);
     $request->getConfig()->set('aws.signature', $sign);
     $body->setField('Signature', base64_encode(hash_hmac('sha256', $sign, $credentials->getSecretKey(), true)));
 }

 /**
  * Calculate signature for request
  *
  * @param RequestInterface $request Request to generate a signature for
  *
  * @return string
  *
  * @throws \RuntimeException
  */
 public function getSignature(RequestInterface $request)
 {
     // For POST|PUT set the JSON body string as the params
     if ($request->getMethod() == 'POST' || $request->getMethod() == 'PUT') {
         $params = $request->getBody()->__toString();
         // Make sure to remove any other query params
         $request->setQuery([]);
     } else {
         $params = Query::fromString($request->getQuery(), Query::RFC1738)->toArray();
         $params = $this->prepareParameters($params);
         // Re-Set the query to the properly ordered query string
         $request->setQuery($params);
         $request->getQuery()->setEncodingType(Query::RFC1738);
     }
     $baseString = $this->createBaseString($request, $params);
     return base64_encode($this->sign_HMAC_SHA256($baseString));
 }

 /**
  * Calculate signature for request
  *
  * This method mostly copy pasted from original class, except its bottom part where we actually hashing our request
  *
  * @param RequestInterface $request Request to generate a signature for
  * @param array $params Oauth parameters.
  *
  * @return string
  */
 public function getSignature(RequestInterface $request, array $params)
 {
     // Remove oauth_signature if present
     // Ref: Spec: 9.1.1 ("The oauth_signature parameter MUST be excluded.")
     unset($params['oauth_signature']);
     // Add POST fields if the request uses POST fields and no files
     $body = $request->getBody();
     if ($body instanceof PostBodyInterface && !$body->getFiles()) {
         $query = Query::fromString($body->getFields(true));
         $params += $query->toArray();
     }
     // Parse & add query string parameters as base string parameters
     $query = Query::fromString((string) $request->getQuery());
     $query->setEncodingType(Query::RFC1738);
     $params += $query->toArray();
     $baseString = $this->createBaseString($request, $this->prepareParameters($params));
     // changed code
     return base64_encode(hash_hmac('sha1', $baseString, $this->consumer_secret, true));
 }

 /**
  * @param \GuzzleHttp\Message\RequestInterface $request
  * @return \SlevomatZboziApi\Request\ZboziApiRequest
  */
 private function getZboziApiRequest(\GuzzleHttp\Message\RequestInterface $request)
 {
     return new ZboziApiRequest($request->getMethod(), $request->getUrl(), $request->getHeaders(), $request->getBody() === null ? null : json_decode((string) $request->getBody()));
 }

 private function modifyRedirectRequest(RequestInterface $request, ResponseInterface $response)
 {
     $config = $request->getConfig();
     // Use a GET request if this is an entity enclosing request and we are
     // not forcing RFC compliance, but rather emulating what all browsers
     // would do.
     $statusCode = $response->getStatusCode();
     if ($statusCode == 303 || $statusCode <= 302 && $request->getBody() && !$config->getPath('redirect/strict')) {
         $request->setMethod('GET');
         $request->setBody(null);
     }
     $previousUrl = $request->getUrl();
     $this->setRedirectUrl($request, $response);
     $this->rewindEntityBody($request);
     // Add the Referer header if it is told to do so and only
     // add the header if we are not redirecting from https to http.
     if ($config->getPath('redirect/referer') && ($request->getScheme() == 'https' || $request->getScheme() == $config['redirect_scheme'])) {
         $url = Url::fromString($previousUrl);
         $url->setUsername(null);
         $url->setPassword(null);
         $request->setHeader('Referer', (string) $url);
     } else {
         $request->removeHeader('Referer');
     }
 }