/**
  * Injects the livereload script.
  *
  * @param Response $response A Response instance
  */
 protected function injectScript(Response $response)
 {
     if (function_exists('mb_stripos')) {
         $posrFunction = 'mb_strripos';
         $substrFunction = 'mb_substr';
     } else {
         $posrFunction = 'strripos';
         $substrFunction = 'substr';
     }
     $content = $response->getContent();
     $pos = $posrFunction($content, '</body>');
     if (false !== $pos) {
         $script = "livereload.js";
         if ($this->checkServerPresence) {
             // GET is required, as livereload apparently does not support HEAD requests ...
             $request = $this->httpClient->get($script);
             try {
                 $checkResponse = $this->httpClient->send($request);
                 if ($checkResponse->getStatusCode() !== 200) {
                     return;
                 }
             } catch (CurlException $e) {
                 // If error is connection failed, we assume the server is not running
                 if ($e->getCurlHandle()->getErrorNo() === 7) {
                     return;
                 }
                 throw $e;
             }
         }
         $content = $substrFunction($content, 0, $pos) . "\n" . '<script src="' . $this->httpClient->getBaseUrl() . $script . '"></script>' . "\n" . $substrFunction($content, $pos);
         $response->setContent($content);
     }
 }
예제 #2
0
 public function getStatusFromWoeid($woeid)
 {
     $request = $this->guzzle->createRequest(self::WEBSERVICE_METHOD, self::WEBSERVICE_URI . $woeid);
     $response = $this->guzzle->send($request);
     $status = $this->parseWeatherResponse($response->xml());
     return $status;
 }
예제 #3
0
 /**
  * Returns a response for specified HTTP request.
  *
  * @param Request $request HTTP Request to send.
  *
  * @return Response Response for specified request.
  */
 public function send(Request $request)
 {
     try {
         $response = $this->client->send($request);
     } catch (BadResponseException $e) {
         $response = $e->getResponse();
     }
     return new Response($response->getStatusCode(), $response->getHeaders(), $response->getBody());
 }
예제 #4
0
 /**
  * @When I send a GET request to :path
  */
 public function iSendAGetRequestTo($path)
 {
     $request = $this->guzzleClient->get('http://localhost:8081' . $path);
     try {
         $this->lastResponse = $this->guzzleClient->send($request);
     } catch (GuzzleResponseException $guzzleResponseException) {
         $this->lastResponse = $guzzleResponseException->getResponse();
     }
 }
 /**
  * @param $spaceId
  * @param array $attributes
  * @return array|\Guzzle\Http\Message\Response|null
  */
 public function getContentEntryBy($spaceId, $contentType, $attributes = [])
 {
     $path = sprintf(self::CONTENTFUL_ENTRIES_URL . "&content_type=%s", $spaceId, $this->accessToken, $contentType);
     foreach ($attributes as $attr => $value) {
         $path .= sprintf("&%s=%s", $attr, $value);
     }
     $request = $this->guzzleClient->get($path, [self::CONTENTFUL_HEADERS_V1_JSON]);
     $response = $this->guzzleClient->send($request);
     return $response;
 }
예제 #6
0
 /**
  * @param string $url
  * @param array  $headers
  * @param array  $options
  *
  * @return array|null
  * @throws \Exception
  */
 public function processQuery($url, $headers = array(), $options = array())
 {
     $request = $this->client->get($url, $headers, $options);
     /**@var Response */
     $response = $this->client->send($request);
     if ($response->isSuccessful()) {
         try {
             return $response->json();
         } catch (RuntimeException $cannotParseJsonException) {
             return $response->getBody(true);
         }
     } else {
         throw new \Exception("Fail to complete the request. Server returns code {$response->getStatusCode()}");
     }
 }
 /**
  * Get RealFaviconGenerator response
  *
  * @param QueryData $queryData RealFaviconGenerator query
  * @return mixed RealFaviconGenerator response
  */
 protected function getResponse(QueryData $queryData)
 {
     $client = new Client($this->generator->getBaseurl());
     $request = $client->post($this->generator->getUri(), null, $queryData->__toString());
     $response = $client->send($request);
     return $response;
 }
예제 #8
0
 /**
  * Use guzzle to make request to API
  *
  * @param Request $request
  * @return string
  */
 protected function makeHttpRequest($request)
 {
     $url = $this->urlBuilder->build($request);
     $guzzleRequest = $this->guzzle->createRequest('GET', $url);
     $guzzleResponse = $this->guzzle->send($guzzleRequest);
     return $guzzleResponse->getBody();
 }
예제 #9
0
파일: ApiClient.php 프로젝트: kix/lykov
 public function __construct($token)
 {
     $client = new Client();
     $request = new Request('POST', self::API_BASE_URL . 'rtm.start?' . http_build_query(['token' => $token]), ['Content-Type' => 'application/x-www-form-urlencoded']);
     $response = $client->send($request);
     var_dump(json_decode($response->getBody(true)));
 }
예제 #10
0
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     if ($input->hasOption('input-file') && $input->getOption('input-file')) {
         $commentFilePath = $input->getOption('input-file');
         if (!file_exists($commentFilePath)) {
             throw new \Exception("{$commentFilePath} not found");
         }
         $commentText = file_get_contents($commentFilePath);
     } else {
         if ($input->hasOption('string') && $input->getOption('string')) {
             $commentText = $input->getOption('string');
         }
     }
     if (!$commentText) {
         throw new \Exception('No comment input, add a comment text with -s or -i options');
     }
     $client = new Client();
     $request = $client->createRequest('GET', 'https://www.pivotaltracker.com/services/v5/me', array('X-TrackerToken' => 'be17fcf368af9fa35cfe88b7460d2c67'));
     $response = $client->send($request);
     $this->projects = array_map(function ($item) {
         return $item['project_id'];
     }, json_decode($response->getBody(), true)['projects']);
     $labelsList = implode(',', $this->projects);
     $extractor = new StoriesExtractor();
     $storyIds = $extractor->collect();
     $storyCount = count($storyIds);
     $output->writeln("Adding comments on {$storyCount} stories on projects {$labelsList}");
     foreach ($storyIds as $storyId) {
         foreach ($this->projects as $project) {
             $request = $client->createRequest('POST', "https://www.pivotaltracker.com/services/v5/projects/{$project}/stories/{$storyId}/comments");
             $request->setHeader('X-TrackerToken', 'be17fcf368af9fa35cfe88b7460d2c67');
             $request->setHeader('Content-type', 'application/json');
             $request->setHeader('Accept', 'application/json');
             $request->setBody(json_encode(['text' => $commentText]));
             try {
                 $client->send($request);
                 $output->write('.');
                 break;
             } catch (ClientErrorResponseException $ex) {
                 $output->writeln('Could not comment on story ' . $storyId);
                 $output->writeln($ex->getResponse()->getBody(true), true);
             }
         }
     }
     $output->writeln('');
 }
 /**
  * {@inheritDoc}
  */
 public function performRequest($url, $parameters, $httpMethod = 'GET')
 {
     $request = $this->createRequest($url, $parameters, $httpMethod);
     try {
         $response = $this->client->send($request);
         return $response;
     } catch (\Imgur\Exception\LogicException $e) {
         error_log($e->getMessage());
     } catch (\Imgur\Exception\RuntimeException $e) {
         error_log($e->getMessage());
     } catch (\Guzzle\Http\Exception\ClientErrorResponseException $e) {
         $responseData = $e->getResponse()->json();
         error_log('Request to: ' . $responseData['data']['request'] . ' failed with: [' . $responseData['status'] . ']"' . $responseData['data']['error'] . '"');
     } catch (Exception $e) {
         error_log($e->getMessage());
     }
     return false;
 }
예제 #12
0
 function it_sends_requests(HttpClient $http, UniqushRequest $uniqushRequest, RequestInterface $request, EntityBodyInterface $responseBody)
 {
     $uniqushRequest->getUrl()->willReturn('/push');
     $uniqushRequest->getQuery()->willReturn($query = ['service' => 'test', 'subscriber' => 'foo', 'msg' => 'bar']);
     $http->post('/push', [], $query)->shouldBeCalled()->willReturn($request);
     $http->send($request)->shouldBeCalled()->willReturn($responseBody);
     $responseBody->__toString()->willReturn('OK');
     $this->send($uniqushRequest)->shouldReturn('OK');
 }
예제 #13
0
 /**
  * Call Guzzle Post request method
  *
  * @param  array $data Address data
  * @param  string $verb Method to be called - should only be geocode for now
  * @return Guzzle\Http\Message\Response
  */
 protected function bulkPost($data, $fields, $verb = 'geocode')
 {
     $url = self::BASE_URL . $verb . "?fields=" . implode(',', $fields) . "&api_key=" . $this->apiKey;
     $headers = ['Content-Type' => 'application/json'];
     $payload = json_encode($data);
     $request = $this->client->post($url, $headers, $payload, []);
     $response = $this->client->send($request);
     return $this->checkResponse($response);
 }
예제 #14
0
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $label = $input->getArgument('label');
     $extractor = new StoriesExtractor();
     $storyIds = $extractor->collect();
     $client = new Client();
     $request = $client->createRequest('GET', 'https://www.pivotaltracker.com/services/v5/me', array('X-TrackerToken' => 'be17fcf368af9fa35cfe88b7460d2c67'));
     $response = $client->send($request);
     $this->projects = array_map(function ($item) {
         return $item['project_id'];
     }, json_decode($response->getBody(), true)['projects']);
     $labelsList = implode(',', $this->projects);
     $storyCount = count($storyIds);
     $output->writeln("Labeling {$storyCount} stories on projects {$labelsList}");
     foreach ($storyIds as $storyId) {
         foreach ($this->projects as $project) {
             $request = $client->createRequest('GET', "https://www.pivotaltracker.com/services/v5/projects/{$project}/stories/{$storyId}", ['X-TrackerToken' => 'be17fcf368af9fa35cfe88b7460d2c67']);
             //                $request->setHeader§('X-TrackerToken', 'be17fcf368af9fa35cfe88b7460d2c67');
             try {
                 $storyData = $client->send($request);
             } catch (ClientErrorResponseException $ex) {
                 continue;
             }
             $body = $storyData->getBody(true);
             $storyData = json_decode($body, true);
             $labels = $storyData['labels'];
             $labels[] = ['name' => $label];
             $request = $client->createRequest('PUT', "https://www.pivotaltracker.com/services/v5/projects/{$project}/stories/{$storyId}");
             $request->setHeader('X-TrackerToken', 'be17fcf368af9fa35cfe88b7460d2c67');
             $request->setHeader('Content-type', 'application/json');
             $request->setHeader('Accept', 'application/json');
             $request->setBody(json_encode(['labels' => $labels]));
             try {
                 $client->send($request);
                 $output->write('.');
                 break;
             } catch (ClientErrorResponseException $ex) {
                 $output->writeln('Could not label story ' . $storyId);
                 $output->writeln($ex->getResponse()->getBody(true), true);
             }
         }
     }
     $output->writeln('');
 }
예제 #15
0
 /**
  * @param GuzzleRequest $request
  * @return GuzzleRequest
  */
 private function processRequest(GuzzleRequest $request)
 {
     try {
         $response = $this->client->send($request);
     } catch (TransferException $e) {
         $json_exception = $e->getResponse()->json();
         HipChat::throwException($json_exception['error']['code'], $json_exception['error']['message'], $request->getUrl());
     }
     return $response;
 }
예제 #16
0
파일: Http.php 프로젝트: goetas/webservices
 /**
  * @return string
  */
 public function send($xml, Port $port, BindingOperation $bindingOperation)
 {
     $url = $port->getDomElement()->evaluate("string(soap:address/@location)", array("soap" => SoapClient::NS));
     $soapAction = $bindingOperation->getDomElement()->evaluate("string(soap:operation/@soapAction)", array("soap" => SoapClient::NS));
     $request = new EntityEnclosingRequest("POST", $url);
     $request->setBody($xml, "text/xml; charset=utf-8");
     $request->addHeader("SOAPAction", '"' . $soapAction . '"');
     if ($this->debugUri) {
         $request->setUrl($this->debugUri);
     }
     try {
         $response = $this->client->send($request);
     } catch (BadResponseException $e) {
         $response = $e->getResponse();
     }
     if (!$response->isSuccessful() && strpos($response->getContentType(), '/xml') === false) {
         throw new TransportException($response->getReasonPhrase(), $response->getStatusCode());
     }
     return $response->getBody(true);
 }
 /**
  * @return array|\Guzzle\Http\Message\Response|null
  */
 private function performCall(HttpClient $httpClient)
 {
     try {
         return $httpClient->send($this->request);
     } catch (RequestException $e) {
         $response = $e->getResponse();
         if (null === $response) {
             throw $e;
         }
         return $response;
     }
 }
예제 #18
0
파일: SocketClient.php 프로젝트: kix/lykov
 private function getEndpoint($token)
 {
     $client = new Client();
     $request = new Request('POST', 'https://slack.com/api/rtm.start?' . http_build_query(['token' => $token]), ['Content-Type' => 'application/x-www-form-urlencoded']);
     $this->emitter->emit('log', ['Requesting RTM start']);
     $response = $client->send($request);
     $responseData = json_decode($response->getBody(true));
     $this->emitter->emit('log', ['RTM started']);
     $this->selfId = $responseData->self->id;
     $this->emitter->emit('log', ['My ID is: ' . $this->selfId]);
     return $responseData->url;
 }
예제 #19
0
 public function doManyRequests(array $requests, array $headers = array())
 {
     $totalToDo = count($requests);
     $responses = array();
     try {
         while ($totalToDo > 0) {
             $clientRequests = array();
             for ($i = 0; $i < $this->parallelLimit && $totalToDo > 0; $i++, $totalToDo--) {
                 $clientRequests[] = $this->client->post('', $headers, json_encode(array_shift($requests)));
             }
             $responses = array_merge($responses, $this->client->send($clientRequests));
         }
     } catch (\Exception $e) {
         throw new Exception('Error in request : ' . $e->getMessage());
     }
     $results = array();
     foreach ($responses as $k => $response) {
         $results[$k] = $this->parseResponse($response);
     }
     return $results;
 }
예제 #20
0
 /**
  * @param ReportDefinition[] $report_definitions
  *
  * @return array
  * @throws \Exception
  */
 public function downloadReports($report_definitions)
 {
     $responses = array();
     $offset = 0;
     do {
         list($sliced_report_definitions_count, $requests) = $this->getNextRequests($report_definitions, $offset);
         // if $requests is none, wait a moment to free some slots and try again
         if (count($requests) == 0) {
             usleep(10000);
             continue;
         }
         try {
             $responses = array_merge($responses, $this->client->send($requests));
         } catch (MultiTransferException $e) {
             $this->freeUsedRequestCount($sliced_report_definitions_count);
             $messages = '';
             foreach ($e as $exception) {
                 /** @noinspection PhpUndefinedMethodInspection */
                 $element = new \SimpleXMLElement($exception->getResponse()->getBody('true'));
                 $api_error = $element->ApiError->type;
                 $trigger = $element->ApiError->trigger;
                 $messages .= $api_error . ' : ' . $trigger . "\n";
             }
             throw new \Exception($messages);
         }
         $this->freeUsedRequestCount($sliced_report_definitions_count);
     } while (count($responses) < count($report_definitions));
     $reports = array();
     /** @var Response[] $responses */
     foreach ($responses as $response) {
         $response_body = $response->getBody(true);
         $xml = gzdecode($response_body);
         $report = $this->xml_parser->reportXmlToArray($xml);
         $reports[] = $report;
     }
     $this->fixFieldTypes($reports, $report_definitions);
     return $reports;
 }
 /**
  * @param Request $request
  *
  * @return array|mixed
  */
 public function callAPI(Request $request)
 {
     try {
         $client = new Client($this->getEndpoint());
         $request = $this->beforeSend($request);
         $method = $request->getMethod();
         $params = $request->getParameters();
         $mergedResponse = null;
         $currentPage = 1;
         $totalPages = 1;
         while ($totalPages >= $currentPage) {
             $apiRequest = $client->createRequest($method, $request->getUrl(), $request->getHeaders(), $request->getBody(), array());
             // Enable pagination
             if ($method === 'GET') {
                 $params['page'] = $currentPage;
             }
             // Assign parameters
             $query = $apiRequest->getQuery();
             foreach ($params as $key => $value) {
                 $query->set($key, $value);
             }
             // Since Guzzle automatically overwrites a new header when the request
             // is POST / PATCH / DELETE / PUT, we need to overwrite the Content-Type header
             // with setBody() function.
             if ($method !== 'GET') {
                 $apiRequest->setBody(json_encode($request->getBody()), 'application/json');
             }
             $response = $client->send($apiRequest)->json();
             if (json_last_error() !== JSON_ERROR_NONE) {
                 throw new BadResponseException('Error decoding client API JSON', $response);
             }
             if (!$this->responseOk($response)) {
                 $this->logAPICall($this->getAPIClientName(), array('type' => 'response', 'body' => $response), true);
             }
             if (isset($response['result_info'])) {
                 $totalPages = $response['result_info']['total_pages'];
                 $mergedResponse = $this->mergeResponses($mergedResponse, $response);
             } else {
                 $mergedResponse = $response;
             }
             $currentPage += 1;
         }
         return $mergedResponse;
     } catch (BadResponseException $e) {
         $errorMessage = $this->getErrorMessage($e);
         $this->logAPICall($this->getAPIClientName(), array('type' => 'request', 'method' => $request->getMethod(), 'path' => $request->getUrl(), 'headers' => $request->getHeaders(), 'params' => $request->getParameters(), 'body' => $request->getBody()), true);
         $this->logAPICall($this->getAPIClientName(), array('type' => 'response', 'reason' => $e->getResponse()->getReasonPhrase(), 'code' => $e->getResponse()->getStatusCode(), 'body' => $errorMessage, 'stacktrace' => $e->getTraceAsString()), true);
         return $this->createAPIError($errorMessage);
     }
 }
예제 #22
0
 /**
  * @param string $repository
  * @param string $format
  *
  * @return \PUGX\Badge\Model\Badge
  */
 public function createComposerLockBadge($repository, $format = 'svg')
 {
     $repo = str_replace('.git', '', $this->packageRepository->fetchByRepository($repository)->getOriginalObject()->getRepository());
     $request = $this->client->head($repo . '/blob/master/composer.lock', array(), array('timeout' => 2, 'connect_timeout' => 1, 'exceptions' => false));
     $response = $this->client->send($request);
     $status = 500;
     if ($request) {
         $status = $response->getStatusCode();
     }
     $this->text = self::LOCK_ERROR;
     $color = self::COLOR_ERROR;
     $subject = self::SUBJECT_ERROR;
     if (200 === $status) {
         $this->text = self::LOCK_COMMITTED;
         $color = self::COLOR_COMMITTED;
         $subject = self::SUBJECT;
     } elseif (404 === $status) {
         $this->text = self::LOCK_UNCOMMITTED;
         $color = self::COLOR_UNCOMMITTED;
         $subject = self::SUBJECT;
     }
     return $this->createBadgeFromRepository($repository, $subject, $color, $format);
 }
예제 #23
0
 /**
  * Patch (partial update) an object at a set location ($path)
  * @param string $path the path to post this object to.
  * @param object $object the object to be posted to given path
  * @param array $headers an array of headers to send with the request
  * @return \DrestClient\Response $response Response object with a populated representation instance
  * @throws ErrorException upon the return of any error document from the server
  */
 public function patch($path, &$object, array $headers = array())
 {
     $representation = $this->getRepresentationInstance();
     $representation->update($object);
     $request = $this->transport->patch($path, $headers, $representation->__toString());
     foreach ($this->getVarsFromPath($path) as $key => $value) {
         $request->setPostField($key, $value);
     }
     $request->setHeader('Content-Type', $representation->getContentType());
     try {
         $response = $this->transport->send($request);
     } catch (BadResponseException $exception) {
         throw $this->handleErrorResponse($exception);
     }
     return new Response($representation, $response);
 }
예제 #24
0
 /**
  * @param string $repo
  * @param string $branch
  * @return Response
  */
 protected function getQueueLocation($repo, $branch)
 {
     $header = $this->getCrumbHeader();
     $post = new EntityEnclosingRequest('POST', $this->buildUrl, [$header]);
     $post->setAuth($this->username, $this->passkey)->setPath('/job/' . $repo . '/buildWithParameters/api/xml')->setPostField('BUILD_TYPE', $branch);
     try {
         return $this->httpClient->send($post);
     } catch (ClientErrorResponseException $e) {
         $response = $e->getResponse();
         switch ($response->getStatusCode()) {
             case 404:
                 throw new \InvalidArgumentException("Repository '{$repo}' not found");
             default:
                 throw new $e();
         }
     }
 }
예제 #25
0
파일: Request.php 프로젝트: magium/magium
 /**
  * @param $method
  * @param $url
  * @param array|null $payload
  * @return array|Response|null
  */
 protected function doRequest($method, $url, array $payload = null)
 {
     if ($this->apiConfiguration->getEnabled()) {
         if ($payload) {
             $payload = ['payload' => json_encode($payload)];
         }
         $url = 'http://' . $this->apiConfiguration->getApiHostname() . $url;
         $factory = new Factory();
         $requestSigner = $factory->newRequestSigner();
         $credentials = new Credentials($this->apiConfiguration->getKey(), $this->apiConfiguration->getSecret());
         $guzzle = new Client();
         $request = $guzzle->createRequest($method, $url, ['content-type' => 'application/json'], $payload);
         $requestSigner->signRequest(new GuzzleRequestAdapter($request), $credentials);
         $response = $guzzle->send($request);
         return $response;
     }
     return null;
 }
예제 #26
0
 /**
  * @param Guzzle\Http\Message\RequestInterface $request
  * @return Guzzle\Http\Message\Response|null
  * @throws Exception\AccessTokenException
  * @throws \Exception
  */
 private function sendRequest(Guzzle\Http\Message\RequestInterface $request)
 {
     // Clean the query string of any null valued parameters
     $request->getQuery()->replace(array_filter($request->getQuery()->toArray()));
     try {
         return $this->guzzleClient->send($request);
     } catch (Guzzle\Http\Exception\ClientErrorResponseException $e) {
         switch ($e->getResponse()->getStatusCode()) {
             case 401:
                 throw new Exception\AccessTokenException();
                 break;
             default:
                 $hydrator = new Hydrator\ErrorHydrator();
                 $error = $hydrator->hydrate($e->getResponse()->json(), new Entity\Error());
                 throw new Exception\SpotifyException($error);
                 break;
         }
     }
 }
예제 #27
0
 /**
  * Send the request
  */
 public function send()
 {
     // make a request object
     $this->request = $this->client->createRequest($this->method, $this->host . $this->resource);
     // set headers
     foreach ($this->headers as $header => $value) {
         $this->request->setHeader($header, $value);
     }
     // set body
     if (!empty($this->body)) {
         $this->request->setBody($this->body);
     }
     try {
         // finally send the request
         $this->response = $this->client->send($this->request);
     } catch (BadResponseException $e) {
         $this->response = $this->request->getResponse();
     }
     $this->sent = true;
 }
예제 #28
0
 /**
  * Get a Klout\Model\User by their Klout ID.
  *
  * @param  String                    $kloutId
  * @param  Boolean                   $fullData
  * @throws InvalidArgumentException
  * @throws ResourceNotFoundException
  * @return \Klout\Model\User
  */
 public function getUser($kloutId, $fullData = true)
 {
     $this->assertValidUserIdForNetwork(self::NETWORK_KLOUT, $kloutId);
     try {
         // Get the data for the user
         $requests = array($this->client->get('user.json/' . $kloutId));
         if ($fullData) {
             $requests[] = $this->client->get('user.json/' . $kloutId . '/influence');
             $requests[] = $this->client->get('user.json/' . $kloutId . '/topics');
         }
         $responses = $this->client->send($requests);
     } catch (HttpRequestException $e) {
         // If there are partial responses then the method
         // will return those responses
         $responses = $this->handleHttpRequestException($e);
     }
     $influenceData = array();
     $topicsData = array();
     $userData = array();
     /* @var $response Response */
     foreach ($responses as $response) {
         if (stripos($response->getEffectiveUrl(), '/influence') !== false) {
             $influenceData = $response->json();
         } elseif (stripos($response->getEffectiveUrl(), '/topics') !== false) {
             $topicsData = $response->json();
         } else {
             $userData = $response->json();
         }
     }
     if (empty($userData)) {
         throw new ResourceNotFoundException('Could not find the user information for Klout user ID: ' . $kloutId);
     }
     $user = new User();
     $user->populate($userData, $influenceData, $topicsData);
     $identity = new Identity();
     $identity->setKloutId($kloutId);
     $identity->setNetworkName(self::NETWORK_KLOUT);
     $identity->setNetworkUserId($kloutId);
     $user->addIdentity($identity);
     return $user;
 }
예제 #29
0
 /**
  * @param RequestInterface       $request
  *
  * @param string                 $className If you omit this parameter you will get Response object
  * @param DeserializationContext $context
  *
  * @return FacilitiesResponse|Facility|Address|AddressesResponse|DoctorsResponse|Doctor|DoctorServicesResponse|ServicesResponse|BookingsResponse|BookVisitResponse|PutSlotsResponse|SlotsResponse|Response
  * @throws \Exception
  */
 private function authorizedRequest(RequestInterface $request, $className = null, DeserializationContext $context = null)
 {
     /** @var FacilitiesResponse|Facility|Address|AddressesResponse|DoctorsResponse|Doctor|DoctorServicesResponse|ServicesResponse|BookingsResponse|BookVisitResponse|PutSlotsResponse|SlotsResponse $object */
     /** @var Error $error */
     $object = null;
     $response = null;
     $error = null;
     if ($this->isAuthorized() === false) {
         $error = (new Error())->setCode(403)->setMessage('Token is neither valid nor authorized');
     }
     try {
         $response = $this->client->send($request);
     } catch (BadResponseException $e) {
         /*
          * You may want to tolerate 40x errors,
          * For example:
          * - If parameters can't be validated you will receive 400
          * - If there isn't any item to show, you will receive 404
          * - If you try to access unauthorized doctor or facility or address you will receive 403
          */
         $response = $e->getResponse();
         $statusCode = $response->getStatusCode();
         $error = $this->serializer->deserialize($response->getBody(true), Error::class, 'json');
         $error->setCode($statusCode);
     }
     //We don't know expected return type so just return raw response.
     if ($className === null) {
         return $response;
     }
     //If there was an error, instantiate the expected class and set the actual Error object;
     //If not then we should simply return the expected class instance with data.
     if ($error === null) {
         $object = $this->serializer->deserialize($response->getBody(true), $className, 'json', $context);
     } else {
         $object = new $className();
         $object->setError($error);
     }
     return $object;
 }
 /**
  * @covers Guzzle\Http\Curl\CurlMulti
  * @covers Guzzle\Http\Curl\CurlMulti::removeErroredRequest
  * @expectedException Guzzle\Common\Exception\ExceptionCollection
  * @expectedExceptionMessage Thrown before sending!
  */
 public function testCatchesExceptionsBeforeSendingRequests()
 {
     $client = new Client($this->getServer()->getUrl());
     $request = $client->get();
     $request->getEventDispatcher()->addListener('request.before_send', function () {
         throw new \RuntimeException('Thrown before sending!');
     });
     $client->send(array($request));
 }