PHP Http\ClientInterface类代码示例

 /**
  * @param ClientInterface $client
  * @param LoggerInterface $logger
  * @param null|string $formatter
  * @return LogPlugin
  */
 public static function addPsrLoggerToClient(ClientInterface $client, LoggerInterface $logger, $formatter = self::SIMPLE_FORMAT)
 {
     $formatter = is_null($formatter) ? self::SIMPLE_FORMAT : $formatter;
     $adapter = new PsrLogAdapter($logger);
     $plugin = new LogPlugin($adapter, $formatter);
     $client->addSubscriber($plugin);
     return $plugin;
 }

 /**
  * Factory method which allows for easy service creation
  *
  * @param  ClientInterface $client
  * @return self
  */
 public static function factory(ClientInterface $client)
 {
     $identity = new self();
     if (($client instanceof Base || $client instanceof OpenStack) && $client->hasLogger()) {
         $identity->setLogger($client->getLogger());
     }
     $identity->setClient($client);
     $identity->setEndpoint(clone $client->getAuthUrl());
     return $identity;
 }

 /**
  * Factory method which allows for easy service creation
  *
  * @param  ClientInterface $client
  * @return self
  */
 public static function factory(\Guzzle\Http\ClientInterface $client)
 {
     $tempAuth = new self();
     if (($client instanceof \OpenCloud\Common\Base || $client instanceof \OpenCloud\OpenStack) && $client->hasLogger()) {
         $tempAuth->setLogger($client->getLogger());
     }
     $tempAuth->setClient($client);
     $tempAuth->setEndpoint(clone $client->getAuthUrl());
     return $tempAuth;
 }

 /**
  * {@inheritdoc}
  */
 public function load(ClassMetadata $metadata, ParserInterface $parser)
 {
     // Create a request with basic Auth
     $request = $this->client->get('repos/' . $this->owner . '/' . $this->repository . '/contents');
     try {
         // Send the request and get the response.
         $response = $request->send();
     } catch (ClientErrorResponseException $e) {
         $this->handleBadResponseExceptions($e);
     }
     $files = $response->json();
     $batch = array();
     foreach ($files as $file) {
         $batch[] = $this->client->get('repos/' . $this->owner . '/' . $this->repository . '/contents/' . $file['path']);
     }
     try {
         $responses = $this->client->send($batch);
     } catch (MultiTransferException $e) {
         $this->handleBadResponseExceptions($e->getFirst());
     }
     $content = array();
     foreach ($responses as $response) {
         $file = $response->json();
         $decodedContent = base64_decode($file['content']);
         $content[] = $parser->parse($metadata, $file['name'], $decodedContent);
     }
     return $content;
 }

 /**
  * Load remote WSDL to local cache.
  *
  * @param string $url
  * @return string
  */
 public function loadWsdl($url)
 {
     $response = $this->guzzleClient->get($url)->send();
     $cacheFilePath = $this->getCachedWsdlPath($url);
     $this->fs->dumpFile($cacheFilePath, $response->getBody(true));
     return $cacheFilePath;
 }

 /**
  * {@inheritdoc}
  */
 public function post($url, array $headers = array(), $content = '')
 {
     $headers['content-type'] = 'application/json';
     $request = $this->client->post($url, $headers, $content);
     $this->response = $request->send();
     return $this->response->getBody(true);
 }

 /**
  * {@inheritdoc}
  */
 public function load(ClassMetadata $metadata, ParserInterface $parser)
 {
     // Create a request with basic Auth
     $request = $this->client->get('metadata/dropbox/' . $this->path);
     try {
         // Send the request and get the response.
         $response = $request->send();
     } catch (ClientErrorResponseException $e) {
         $this->handleBadResponseExceptions($e);
     }
     $responseBody = $response->json();
     $batch = array();
     foreach ($responseBody['contents'] as $file) {
         $batch[] = $this->client->get('https://api-content.dropbox.com/1/files/dropbox' . $file['path']);
     }
     try {
         $responses = $this->client->send($batch);
     } catch (MultiTransferException $e) {
         $this->handleBadResponseExceptions($e->getFirst());
     }
     $content = array();
     foreach ($responses as $response) {
         $url = parse_url($response->getEffectiveUrl());
         $filename = basename($url['path']);
         $receivedContent = $response->getBody(true);
         $content[] = $parser->parse($metadata, $filename, $receivedContent);
     }
     return $content;
 }

 /**
  * Sends the request to given URL and returns JSON response.
  * 
  * @param string
  * @return void
  */
 public function handleRequest($url)
 {
     $request = $this->client->get($url);
     $json = ['success' => TRUE, 'error' => NULL, 'body' => NULL];
     $this->enableCrossDomainRequests();
     try {
         $result = $request->send(TRUE);
     } catch (CurlException $e) {
         $json['success'] = FALSE;
         $json['error'] = sprintf("Unable to handle request: CURL failed with message '%s'.", $e->getError());
         switch ($e->getErrorNo()) {
             case CURLE_COULDNT_RESOLVE_HOST:
                 http_response_code(404);
                 break;
             default:
                 http_response_code(400);
                 break;
         }
     }
     if (isset($result)) {
         $json['body'] = $result->getBody(TRUE);
     }
     header('Content-Type: application/json');
     echo json_encode($json);
 }

 /**
  * {@inheritdoc}
  */
 public function getMessage($id)
 {
     try {
         return $this->guzzle->get('/messages/' . $id . '.json')->send()->json();
     } catch (GuzzleException $e) {
         throw new ConnectionException("", 0, $e);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function put($url, array $headers = array(), array $content = array(), array $files = array())
 {
     $request = $this->client->put($url, $headers, $content);
     foreach ($files as $key => $file) {
         $request->addPostFile($key, $file);
     }
     return $this->sendRequest($request);
 }

 /**
  * Load remote WSDL to local cache.
  *
  * @param string $url
  * @return string
  */
 public function loadWsdl($url)
 {
     $clientOptions = ['verify' => empty($this->bundleConfig['sync_settings']['skip_ssl_verification'])];
     $response = $this->guzzleClient->get($url, null, $clientOptions)->send();
     $cacheFilePath = $this->getCachedWsdlPath($url);
     $this->fs->dumpFile($cacheFilePath, $response->getBody(true));
     return $cacheFilePath;
 }

 public function track($trackingNumber)
 {
     try {
         $response = $this->httpClient->post($this->url, array(), array('API' => 'TrackV2', 'XML' => $this->createTrackRequestXml($trackingNumber)))->send();
     } catch (HttpException $e) {
         throw Exception::createFromHttpException($e);
     }
     return $this->parseTrackResponse($response->getBody(true), $trackingNumber);
 }

 public function track($trackingNumber)
 {
     try {
         $response = $this->httpClient->get($this->url, array(), array('query' => array('RQXML' => $this->createRequestXml($trackingNumber))))->send();
     } catch (HttpException $e) {
         throw Exception::createFromHttpException($e);
     }
     return $this->parse($response->getBody(true));
 }

 /**
  * @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(RequestInterface::POST, $endpoint, $headers, $content, array('exceptions' => false));
     if ($files && $request instanceof EntityEnclosingRequestInterface) {
         $request->addPostFiles($files);
     }
     $response = $request->send();
     return new Response($response->getStatusCode(), $response->getBody(true));
 }

 /**
  * @param string $access_token
  * @return User
  */
 public function getByAccessToken($access_token)
 {
     $me = $this->http->get('https://graph.facebook.com/me?access_token=' . $access_token)->send()->json();
     $data = $this->data_provider->findUserByFacebookId($me['id']);
     $user = null;
     if ($data != null) {
         $user = $this->createUser($data);
     }
     return $user;
 }