示例#1
0
 public function execute()
 {
     $body = '';
     /** @var Google_Http_Request $req */
     foreach ($this->requests as $key => $req) {
         $body .= "--{$this->boundary}\n";
         $body .= $req->toBatchString($key) . "\n";
         $this->expected_classes["response-" . $key] = $req->getExpectedClass();
     }
     $body = rtrim($body);
     $body .= "\n--{$this->boundary}--";
     $url = $this->base_path . '/batch';
     $httpRequest = new Google_Http_Request($url, 'POST');
     $httpRequest->setRequestHeaders(array('Content-Type' => 'multipart/mixed; boundary=' . $this->boundary));
     $httpRequest->setPostBody($body);
     $response = $this->client->getIo()->makeRequest($httpRequest);
     return $this->parseResponse($response);
 }
 /**
  * @param $meta
  * @param $params
  * @return array|bool
  * @visible for testing
  */
 private function process()
 {
     $postBody = false;
     $contentType = false;
     $meta = $this->request->getPostBody();
     $meta = is_string($meta) ? json_decode($meta, true) : $meta;
     $uploadType = $this->getUploadType($meta);
     $this->request->setQueryParam('uploadType', $uploadType);
     $this->transformToUploadUrl();
     $mimeType = $this->mimeType ? $this->mimeType : $this->request->getRequestHeader('content-type');
     if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
         $contentType = $mimeType;
         $postBody = is_string($meta) ? $meta : json_encode($meta);
     } else {
         if (self::UPLOAD_MEDIA_TYPE == $uploadType) {
             $contentType = $mimeType;
             $postBody = $this->data;
         } else {
             if (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
                 // This is a multipart/related upload.
                 $boundary = $this->boundary ? $this->boundary : mt_rand();
                 $boundary = str_replace('"', '', $boundary);
                 $contentType = 'multipart/related; boundary=' . $boundary;
                 $related = "--{$boundary}\r\n";
                 $related .= "Content-Type: application/json; charset=UTF-8\r\n";
                 $related .= "\r\n" . json_encode($meta) . "\r\n";
                 $related .= "--{$boundary}\r\n";
                 $related .= "Content-Type: {$mimeType}\r\n";
                 $related .= "Content-Transfer-Encoding: base64\r\n";
                 $related .= "\r\n" . base64_encode($this->data) . "\r\n";
                 $related .= "--{$boundary}--";
                 $postBody = $related;
             }
         }
     }
     $this->request->setPostBody($postBody);
     if (isset($contentType) && $contentType) {
         $contentTypeHeader['content-type'] = $contentType;
         $this->request->setRequestHeaders($contentTypeHeader);
     }
 }
 /**
  * TODO(ianbarber): This function needs simplifying.
  * @param $name
  * @param $arguments
  * @param $expected_class - optional, the expected class name
  * @return Google_Http_Request|expected_class
  * @throws Google_Exception
  */
 public function call($name, $arguments, $expected_class = null)
 {
     if (!isset($this->methods[$name])) {
         throw new Google_Exception("Unknown function: " . "{$this->serviceName}->{$this->resourceName}->{$name}()");
     }
     $method = $this->methods[$name];
     $parameters = $arguments[0];
     // postBody is a special case since it's not defined in the discovery
     // document as parameter, but we abuse the param entry for storing it.
     $postBody = null;
     if (isset($parameters['postBody'])) {
         if ($parameters['postBody'] instanceof Google_Model) {
             // In the cases the post body is an existing object, we want
             // to use the smart method to create a simple object for
             // for JSONification.
             $parameters['postBody'] = $parameters['postBody']->toSimpleObject();
         } else {
             if (is_object($parameters['postBody'])) {
                 // If the post body is another kind of object, we will try and
                 // wrangle it into a sensible format.
                 $parameters['postBody'] = $this->convertToArrayAndStripNulls($parameters['postBody']);
             }
         }
         $postBody = json_encode($parameters['postBody']);
         unset($parameters['postBody']);
     }
     // TODO(ianbarber): optParams here probably should have been
     // handled already - this may well be redundant code.
     if (isset($parameters['optParams'])) {
         $optParams = $parameters['optParams'];
         unset($parameters['optParams']);
         $parameters = array_merge($parameters, $optParams);
     }
     if (!isset($method['parameters'])) {
         $method['parameters'] = array();
     }
     $method['parameters'] = array_merge($method['parameters'], $this->stackParameters);
     foreach ($parameters as $key => $val) {
         if ($key != 'postBody' && !isset($method['parameters'][$key])) {
             throw new Google_Exception("({$name}) unknown parameter: '{$key}'");
         }
     }
     foreach ($method['parameters'] as $paramName => $paramSpec) {
         if (isset($paramSpec['required']) && $paramSpec['required'] && !isset($parameters[$paramName])) {
             throw new Google_Exception("({$name}) missing required param: '{$paramName}'");
         }
         if (isset($parameters[$paramName])) {
             $value = $parameters[$paramName];
             $parameters[$paramName] = $paramSpec;
             $parameters[$paramName]['value'] = $value;
             unset($parameters[$paramName]['required']);
         } else {
             // Ensure we don't pass nulls.
             unset($parameters[$paramName]);
         }
     }
     $servicePath = $this->service->servicePath;
     $url = Google_Http_REST::createRequestUri($servicePath, $method['path'], $parameters);
     $httpRequest = new Google_Http_Request($url, $method['httpMethod'], null, $postBody);
     $httpRequest->setBaseComponent($this->client->getBasePath());
     if ($postBody) {
         $contentTypeHeader = array();
         $contentTypeHeader['content-type'] = 'application/json; charset=UTF-8';
         $httpRequest->setRequestHeaders($contentTypeHeader);
         $httpRequest->setPostBody($postBody);
     }
     $httpRequest = $this->client->getAuth()->sign($httpRequest);
     $httpRequest->setExpectedClass($expected_class);
     if (isset($parameters['data']) && ($parameters['uploadType']['value'] == 'media' || $parameters['uploadType']['value'] == 'multipart')) {
         // If we are doing a simple media upload, trigger that as a convenience.
         $mfu = new Google_Http_MediaFileUpload($this->client, $httpRequest, isset($parameters['mimeType']) ? $parameters['mimeType']['value'] : 'application/octet-stream', $parameters['data']['value']);
     }
     if ($this->client->shouldDefer()) {
         // If we are in batch or upload mode, return the raw request.
         return $httpRequest;
     }
     return $this->client->execute($httpRequest);
 }
 /**
  * @visible for testing
  * Process an http request that contains an enclosed entity.
  * @param Google_Http_Request $request
  * @return Google_Http_Request Processed request with the enclosed entity.
  */
 public function processEntityRequest(Google_Http_Request $request)
 {
     $postBody = $request->getPostBody();
     $contentType = $request->getRequestHeader("content-type");
     // Set the default content-type as application/x-www-form-urlencoded.
     if (false == $contentType) {
         $contentType = self::FORM_URLENCODED;
         $request->setRequestHeaders(array('content-type' => $contentType));
     }
     // Force the payload to match the content-type asserted in the header.
     if ($contentType == self::FORM_URLENCODED && is_array($postBody)) {
         $postBody = http_build_query($postBody, '', '&');
         $request->setPostBody($postBody);
     }
     // Make sure the content-length header is set.
     if (!$postBody || is_string($postBody)) {
         $postsLength = strlen($postBody);
         $request->setRequestHeaders(array('content-length' => $postsLength));
     }
     return $request;
 }