private function _init_service($access_token)
 {
     $client = new \W3TCG_Google_Client();
     $client->setClientId($this->_client_id);
     $client->setAccessToken($access_token);
     $this->_service = new \W3TCG_Google_Service_Drive($client);
 }
Exemplo n.º 2
0
 public function parseResponse(W3TCG_Google_Http_Request $response)
 {
     $contentType = $response->getResponseHeader('content-type');
     $contentType = explode(';', $contentType);
     $boundary = false;
     foreach ($contentType as $part) {
         $part = explode('=', $part, 2);
         if (isset($part[0]) && 'boundary' == trim($part[0])) {
             $boundary = $part[1];
         }
     }
     $body = $response->getResponseBody();
     if ($body) {
         $body = str_replace("--{$boundary}--", "--{$boundary}", $body);
         $parts = explode("--{$boundary}", $body);
         $responses = array();
         foreach ($parts as $part) {
             $part = trim($part);
             if (!empty($part)) {
                 list($metaHeaders, $part) = explode("\r\n\r\n", $part, 2);
                 $metaHeaders = $this->client->getIo()->getHttpResponseHeaders($metaHeaders);
                 $status = substr($part, 0, strpos($part, "\n"));
                 $status = explode(" ", $status);
                 $status = $status[1];
                 list($partHeaders, $partBody) = $this->client->getIo()->ParseHttpResponse($part, false);
                 $response = new W3TCG_Google_Http_Request("");
                 $response->setResponseHttpCode($status);
                 $response->setResponseHeaders($partHeaders);
                 $response->setResponseBody($partBody);
                 // Need content id.
                 $key = $metaHeaders['content-id'];
                 if (isset($this->expected_classes[$key]) && strlen($this->expected_classes[$key]) > 0) {
                     $class = $this->expected_classes[$key];
                     $response->setExpectedClass($class);
                 }
                 try {
                     $response = W3TCG_Google_Http_REST::decodeHttpResponse($response);
                     $responses[$key] = $response;
                 } catch (W3TCG_Google_Service_Exception $e) {
                     // Store the exception as the response, so succesful responses
                     // can be processed.
                     $responses[$key] = $e;
                 }
             }
         }
         return $responses;
     }
     return null;
 }
Exemplo n.º 3
0
 /**
  * @visible for testing.
  * @param W3TCG_Google_Http_Request $request
  * @return W3TCG_Google_Http_Request|bool Returns the cached object or
  * false if the operation was unsuccessful.
  */
 public function getCachedRequest(W3TCG_Google_Http_Request $request)
 {
     if (false === W3TCG_Google_Http_CacheParser::isRequestCacheable($request)) {
         return false;
     }
     return $this->client->getCache()->get($request->getCacheKey());
 }
Exemplo n.º 4
0
 private function getResumeUri()
 {
     $result = null;
     $body = $this->request->getPostBody();
     if ($body) {
         $headers = array('content-type' => 'application/json; charset=UTF-8', 'content-length' => W3TCG_Google_Utils::getStrLen($body), 'x-upload-content-type' => $this->mimeType, 'x-upload-content-length' => $this->size, 'expect' => '');
         $this->request->setRequestHeaders($headers);
     }
     $response = $this->client->getIo()->makeRequest($this->request);
     $location = $response->getResponseHeader('location');
     $code = $response->getResponseHttpCode();
     if (200 == $code && true == $location) {
         return $location;
     }
     $message = $code;
     $body = @json_decode($response->getResponseBody());
     if (!empty($body->error->errors)) {
         $message .= ': ';
         foreach ($body->error->errors as $error) {
             $message .= "{$error->domain}, {$error->message};";
         }
         $message = rtrim($message, ';');
     }
     throw new W3TCG_Google_Exception("Failed to start the resumable upload (HTTP {$message})");
 }
Exemplo n.º 5
0
 public function __construct(W3TCG_Google_Client $client)
 {
     if (!function_exists('memcache_connect') && !class_exists("Memcached")) {
         throw new W3TCG_Google_Cache_Exception("Memcache functions not available");
     }
     if ($client->isAppEngine()) {
         // No credentials needed for GAE.
         $this->mc = new Memcached();
         $this->connection = true;
     } else {
         $this->host = $client->getClassConfig($this, 'host');
         $this->port = $client->getClassConfig($this, 'port');
         if (empty($this->host) || empty($this->port) && (string) $this->port != "0") {
             throw new W3TCG_Google_Cache_Exception("You need to supply a valid memcache host and port");
         }
     }
 }
 function render()
 {
     $client_id = $_GET['oa_client_id'];
     $refresh_token = $_GET['oa_refresh_token'];
     $token_array = array('access_token' => $_GET['oa_access_token'], 'token_type' => $_GET['oa_token_type'], 'expires_in' => $_GET['oa_expires_in'], 'created' => $_GET['oa_created']);
     $access_token = json_encode($token_array);
     $client = new \W3TCG_Google_Client();
     $client->setClientId($client_id);
     $client->setAccessToken($access_token);
     $service = new \W3TCG_Google_Service_Drive($client);
     $items = $service->files->listFiles(array('q' => "mimeType = 'application/vnd.google-apps.folder'"));
     $folders = array();
     foreach ($items as $item) {
         if (count($item->parents) > 0 && $item->parents[0]->isRoot) {
             $folders[] = $item;
         }
     }
     include W3TC_DIR . '/Cdn_GoogleDrive_Popup_AuthReturn_View.php';
 }
 function w3tc_cdn_google_drive_auth_set()
 {
     // thanks wp core for wp_magic_quotes hell
     $client_id = stripslashes($_POST['client_id']);
     $access_token = stripslashes($_POST['access_token']);
     $refresh_token = stripslashes($_POST['refresh_token']);
     $client = new \W3TCG_Google_Client();
     $client->setClientId($client_id);
     $client->setAccessToken($access_token);
     //
     // get folder details
     //
     $service = new \W3TCG_Google_Service_Drive($client);
     if (empty($_POST['folder'])) {
         $file = new \W3TCG_Google_Service_Drive_DriveFile(array('title' => $_POST['folder_new'], 'mimeType' => 'application/vnd.google-apps.folder'));
         $created_file = $service->files->insert($file);
         $used_folder_id = $created_file->id;
     } else {
         $used_folder_id = $_POST['folder'];
     }
     $permission = new \W3TCG_Google_Service_Drive_Permission();
     $permission->setValue('');
     $permission->setType('anyone');
     $permission->setRole('reader');
     $service->permissions->insert($used_folder_id, $permission);
     $used_folder = $service->files->get($used_folder_id);
     //
     // save new configuration
     //
     delete_transient('w3tc_cdn_google_drive_folder_ids');
     $this->_config->set('cdn.google_drive.client_id', $client_id);
     $this->_config->set('cdn.google_drive.refresh_token', $refresh_token);
     $this->_config->set('cdn.google_drive.folder.id', $used_folder->id);
     $this->_config->set('cdn.google_drive.folder.title', $used_folder->title);
     $this->_config->set('cdn.google_drive.folder.url', $used_folder->webViewLink);
     $this->_config->save();
     $cs = Dispatcher::config_state();
     $cs->set('cdn.google_drive.access_token', $access_token);
     $cs->save();
     wp_redirect('admin.php?page=w3tc_cdn', false);
 }
Exemplo n.º 8
0
 /**
  * Executes a W3TCG_Google_Http_Request
  *
  * @param W3TCG_Google_Client $client
  * @param W3TCG_Google_Http_Request $req
  * @return array decoded result
  * @throws W3TCG_Google_Service_Exception on server side error (ie: not authenticated,
  *  invalid or malformed post body, invalid url)
  */
 public static function execute(W3TCG_Google_Client $client, W3TCG_Google_Http_Request $req)
 {
     $httpRequest = $client->getIo()->makeRequest($req);
     $httpRequest->setExpectedClass($req->getExpectedClass());
     return self::decodeHttpResponse($httpRequest);
 }
Exemplo n.º 9
0
 public function __construct(W3TCG_Google_Client $client)
 {
     $this->path = $client->getClassConfig($this, 'directory');
 }
Exemplo n.º 10
0
 /**
  * TODO(ianbarber): This function needs simplifying.
  * @param $name
  * @param $arguments
  * @param $expected_class - optional, the expected class name
  * @return W3TCG_Google_Http_Request|expected_class
  * @throws W3TCG_Google_Exception
  */
 public function call($name, $arguments, $expected_class = null)
 {
     if (!isset($this->methods[$name])) {
         throw new W3TCG_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 W3TCG_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 W3TCG_Google_Exception("({$name}) unknown parameter: '{$key}'");
         }
     }
     foreach ($method['parameters'] as $paramName => $paramSpec) {
         if (isset($paramSpec['required']) && $paramSpec['required'] && !isset($parameters[$paramName])) {
             throw new W3TCG_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 = W3TCG_Google_Http_REST::createRequestUri($servicePath, $method['path'], $parameters);
     $httpRequest = new W3TCG_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 W3TCG_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);
 }