PHP Request::init方法代码示例

 /**
  * @param array $config
  */
 public function __construct($config = array())
 {
     $this->config = array_merge(array('base_uri' => null, 'username' => null, 'password' => null, 'mime' => null, 'timeout' => null), (array) $config);
     $this->base_uri = $this->config['base_uri'];
     $template = Request::init()->mime($this->config['mime']);
     if ($this->config['username']) {
         $template->authenticateWith($this->config['username'], $this->config['password']);
     }
     Request::ini($template);
 }

 /**
  * Construt a Request
  * 
  * @param Auth $auth SkyHub Auth information to send on headers
  */
 public function __construct(Auth $auth)
 {
     $this->auth = $auth;
     $this->jsonHandler = new \SkyHub\Handlers\JsonHandler();
     $this->jsonHandler->init(array());
     Httpful::register(\Httpful\Mime::JSON, $this->jsonHandler);
     // creates a request template, every request must have the auth headers
     $this->requestTemplate = HttpfulRequest::init()->expectsJson()->addHeader('X-User-Email', $this->auth->getEmail())->addHeader('X-User-Token', $this->auth->getToken());
     HttpfulRequest::ini($this->requestTemplate);
 }

 public function navigate($link, $data = null, $queryParams = null)
 {
     $url = $this->url . $link->Uri;
     $request = \Httpful\Request::init()->addHeader("Authorization", $this->getAuthorizationToken())->method($link->Method)->uri($url)->addHeader("Accept", $link->Type)->contentType(findMimeTypeUsingUrl($url));
     if (($link->Method === "POST" || $link->Method === "PUT") && $data !== null) {
         if (property_exists($link, 'VersionNumber')) {
             $request->addHeader($this->ifNoneMatch, $link->VersionNumber);
         }
         $request->body(json_encode($data));
     }
     $response = $request->send();
     $result = null;
     if ($response->hasErrors()) {
         $result = $response->body;
         throw new \NFleetException($result);
     } else {
         if ($link->Method === "GET") {
             $result = $response->body;
             if (isset($response->headers['etag'])) {
                 $result->VersionNumber = $response->headers['etag'];
             }
         } elseif ($link->Method === "POST" || $link->Method === "PUT") {
             $result = $this->createResponseData($response->headers['location'], $response->headers['Content-Type']);
         }
     }
     return $result;
 }

 /**
  * @param $route
  * @param $type
  * @param $data
  * @return array
  * @throws AcendaException
  * @throws Httpful\Exception\ConnectionErrorException
  */
 public function performRequest($route, $type, $data)
 {
     $httpful = Httpful\Request::init();
     if (!$this->bypass_ssl) {
         $httpful = $httpful->withStrictSSL();
     }
     $data_json = is_array($data) ? json_encode($data) : $data;
     $url = $this->store_url . (!empty($this->token['access_token']) ? "/api" . $route . "?access_token=" . $this->token['access_token'] : $route);
     switch (strtoupper($type)) {
         case 'GET':
             //Append the query.
             $url .= "&query=" . $data_json;
             $response = $httpful->get($url)->send();
             break;
         case 'PUT':
             $response = $httpful->put($url, $data_json)->sendsJson()->send();
             break;
         case 'POST':
             $response = $httpful->post($url, $data_json)->sendsJson()->send();
             break;
         default:
             throw new AcendaException('Verb ' . $type . ' Not Understood');
     }
     //Default in this switch is failure. All failures should fall through to default.
     switch ($response->code) {
         case 200:
         case 201:
             return $this->requestSuccess($response);
         default:
             return $this->requestFailure($response);
     }
 }

 /**
  * Prepare request template with default values. All those can be simply 
  * changed by calling appropriate methods on the request, which will override
  * the template set here. Here we set Basic Auth and Accept header to be 
  * used in all requests.
  * 
  */
 protected function prepareRequestTemplate()
 {
     // Create the Request template.
     static::$requestTemplate = Request::init()->method(Http::GET)->basicAuth(static::$settings->isvuUsername, static::$settings->isvuPassword)->addHeader('Accept', static::$settings->defaultAcceptHeader);
     // Set it as a template.
     Request::ini(static::$requestTemplate);
 }

 /**
  * Post Request
  *
  * @param string $uri
  * @return \Httpful\Response
  */
 public function post($uri, $params = array())
 {
     if ($params) {
         $uri .= "?" . http_build_query($params);
     }
     $this->output("POST : " . $uri);
     return new \Httpful\Response("", "HTTP/1.1 200 OK\r\n", \Httpful\Request::init());
 }

 /**
  * GitHubRestClient constructor.
  * @param $request Request
  */
 public function __construct($request = null)
 {
     if (null != $request) {
         $this->request = $request;
     } else {
         $this->request = Request::init();
     }
 }

 /**
  * @param $client_id Developer ID, usually in form of user@domain.com
  * @param $client_secret Developer key provided by Acenda.
  * @param $store_url The URL of the store we are working with.
  * @param $plugin_name Friendly name for localeconv(oid)gs etc. I don't think this is implemented.
  * @param $bypass_ssl Rather the SSL verification should be strict or not.
  * @throws AcendaException
  */
 public function __construct($client_id, $client_secret, $store_name, $bypass_ssl = false)
 {
     $this->httpful = Httpful\Request::init();
     if (!$bypass_ssl) {
         $this->httpful = $this->httpful->withStrictSSL();
     }
     Authentication::init($client_id, $client_secret, $this->httpful);
     $this->generateStoreUrl($store_name);
 }

 /**
  * Make a JSON request
  * 
  * @param string 	$method 	GET, POST, PUT, DELETE, etc.
  * @param array 	$segments 	for example array('account', 'all')
  * @param array 	$data 		the post / put data
  */
 public static function request($method, $segments, $data = array())
 {
     $url = implode('', static::url($segments, $data));
     $config = static::config();
     $response = Request::init($method)->uri($url)->mime('json')->basicAuth($config['username'], $config['password'])->send();
     if ($response->code === 404) {
         throw new Exception('API method "' . $url . '" does not exist.');
     }
     if ($response->code === 401) {
         throw new Exception('Unauthorized to use this API method "' . $url . '".');
     }
     return new Response($response->code, $response->body);
 }

    public function testListUserRepositories()
    {
        $this->mockRequest->expects($this->once())->method('expectsJson')->willReturn($this->mockRequest);
        $this->mockRequest->expects($this->once())->method('uri')->with($this->equalTo('https://api.github.com/users/jgiovaresco/repos'))->willReturn($this->mockRequest);
        $this->mockRequest->expects($this->once())->method('send')->willReturn(new \Httpful\Response('[{
						"id": 123,
						"name": ".vim"
					},{
						"id": 124,
						"name": "repocount"
					}]', "HTTP/1.1 200 OK\n\t\t\t\t\tContent-Type: application/json\n\t\t\t\t\tConnection: keep-alive\n\t\t\t\t\tTransfer-Encoding: chunked\r\n", $req = \Httpful\Request::init()->sendsAndExpects(\Httpful\Mime::JSON)));
        $repositories = $this->gitHubRestClient->listUserRepositories(Employee::builder()->withId('123')->withUsername('jgiovaresco')->build());
        expect($repositories)->to->have->length(2);
        expect($repositories[0]->name())->to->equal('.vim');
        expect($repositories[1]->name())->to->equal('repocount');
    }

 /**
  * Call LendingClub and gather all loans
  *
  * @return callable
  * @throws \Httpful\Exception\ConnectionErrorException
  */
 public function callback()
 {
     $uri = 'https://api.lendingclub.com/api/investor/1/loans/listing';
     /** @var \PhpAmqpLib\Message\AMQPMessage $args */
     return function ($args) use($uri) {
         $request = Request::init('GET');
         $auth_key = json_decode($args->body)[0];
         $request->uri($uri);
         $request->addHeader('Accept', 'application/json');
         $request->addHeader('Content-Type', 'application/json');
         $request->addHeader('Authorization', $auth_key);
         /** @var \Httpful\Response $response */
         $response = $request->send();
         echo $response->code . PHP_EOL;
         // Perform DB operation with response
     };
 }

 /**
  * send off the request to Shopify, encoding the data as JSON
  *
  * @param  string $method
  * @param  string $page
  * @param  array $data
  *
  * @return array
  */
 public function makeRequest($method, $page, $data = [])
 {
     $url = $this->url . "/" . $page;
     if ($method == 'GET' && !empty($data)) {
         $url .= '?' . http_build_query($data);
     }
     $r = Request::init($method)->uri($url);
     if ($data && $method != 'GET') {
         $r->body(json_encode($data), 'application/json');
     }
     $r = $r->send();
     if ($r->code !== 200) {
         return ['error' => $r->body, 'url' => $url, 'request' => '', 'status' => $r->code, 'response' => $r->body];
     } else {
         return json_decode(json_encode($r->body), true);
     }
 }

 public static function makeRequest($method, $uri, $many = false, $payload = array())
 {
     if (empty($method)) {
         throw new \InvalidArgumentException('method');
     }
     if (empty($uri)) {
         throw new \InvalidArgumentException('uri');
     }
     $uri = str_replace('{resource}', self::getResourceName(), $uri);
     $request = \Httpful\Request::init($method)->uri(self::API_URL . $uri)->addHeader('Authorization', "Token " . self::API_KEY)->addHeader('Accept', 'application/json')->sendsJson();
     if (!empty($payload)) {
         if ($method == \Httpful\Http::GET) {
             $query_str = http_build_query($payload, null, '&');
             $query_str = preg_replace('/%5B(?:[0-9]|[1-9][0-9]+)%5D=/', '=', $query_str);
             $request = $request->uri($request->uri . '?' . $query_str);
         } else {
             $request = $request->body($payload);
         }
     }
     $response = $request->send();
     if ($response->code >= 500) {
         throw new \Exception("{$response->code}: Internal server error. Check server logs.");
     } else {
         if ($response->code >= 400) {
             $details = is_object($response->body) ? print_r($response->body, true) : 'Check server logs.';
             throw new \Exception("{$response->code}: {$details}", $response->code);
         }
     }
     if ($many) {
         $resources = array();
         foreach ($response->body->results as $json_res) {
             $resources[] = (array) $json_res;
         }
         if (isset($response->body->next)) {
             $next_url = $response->body->next;
             if ($next_url) {
                 $next_url = substr($next_url, strlen(self::API_URL));
                 $resources = array_merge($resources, self::makeRequest($method, $next_url, $many));
             }
         }
         return $resources;
     } else {
         return (array) $response->body;
     }
 }

 /**
  * Makes a call to the API.
  *
  * This method will make the actial API call by the given arguments. It
  * will return the response on success (200) or will throw an exception
  * on failure.
  *
  * @param string $method The HTTP method to use (e.g. Http::GET, Http::POST, etc.).
  * @param string $resourcePath The path to the resource (e.g. contacts/john@example.com/)
  * @param string $payload The data that is sent to the service. Not used for GET or DELETE.
  * @return \Httpful\Response The response object from the service.
  * @throws \Gan\ApiException
  */
 public function call($method, $resourcePath, $payload = null)
 {
     $uri = $this->baseUri . $resourcePath;
     Request::ini($this->requestTemplate);
     $request = Request::init($method)->uri($uri);
     if ($payload) {
         $request->body($payload);
     }
     try {
         $response = $request->send();
     } finally {
         Request::resetIni();
     }
     if (floor($response->code / 100) != 2) {
         throw new ApiException($response);
     }
     return $response;
 }

 /**
  * Creates an HTTP Request manager with additional header support for Plex.
  * Endpoint is the URL to request from, with optional proxy parameter.
  * expectEmptyResponse when set to true does not try and parse the result as XML.
  *
  * @param string     $endPoint
  * @param bool|Proxy $proxy
  */
 public function __construct($endPoint, $proxy = false, $expectEmptyResponse = false)
 {
     $this->endPoint = $endPoint;
     $this->template = HttpfulRequest::init();
     if ($expectEmptyResponse) {
         $this->template->withoutAutoParse();
     } else {
         $this->template->expectsXml();
     }
     if ($proxy) {
         $this->template->useProxy($proxy->host, $proxy->port, $proxy->authType);
     }
     foreach ($this->headers as $header => $value) {
         if ($value) {
             $this->setHeader($header, $value);
         }
     }
 }