Yoast_Google_Client

The Google API Client http://code.google.com/p/google-api-php-client/.

Defined (1)

The class is defined in the following location(s).

/vendor/yoast/api-libs/google/Google_Client.php  
  1. class Yoast_Google_Client { 
  2.   /** 
  3.    * @static 
  4.    * @var Yoast_Google_Auth $auth 
  5.    */ 
  6.   static $auth; 
  7.  
  8.   /** 
  9.    * @static 
  10.    * @var Yoast_Google_IO $io 
  11.    */ 
  12.   static $io; 
  13.  
  14.   /** 
  15.    * @static 
  16.    * @var Yoast_Google_Cache $cache 
  17.    */ 
  18.   static $cache; 
  19.  
  20.   /** 
  21.    * @static 
  22.    * @var boolean $useBatch 
  23.    */ 
  24.   static $useBatch = false; 
  25.  
  26.   /** @var array $scopes */ 
  27.   protected $scopes = array(); 
  28.  
  29.   /** @var bool $useObjects */ 
  30.   protected $useObjects = false; 
  31.  
  32.   // definitions of services that are discovered. 
  33.   protected $services = array(); 
  34.  
  35.   // Used to track authenticated state, can't discover services after doing authenticate() 
  36.   private $authenticated = false; 
  37.  
  38.   public function __construct($config = array()) { 
  39.     global $apiConfig; 
  40.     $apiConfig = array_merge($apiConfig, $config); 
  41.     self::$cache = new $apiConfig['cacheClass'](); 
  42.     self::$auth = new $apiConfig['authClass'](); 
  43.     self::$io = new $apiConfig['ioClass'](); 
  44.   } 
  45.  
  46.   /** 
  47.    * Add a service 
  48.    */ 
  49.   public function addService($service, $version = false) { 
  50.     global $apiConfig; 
  51.     if ($this->authenticated) { 
  52.       throw new Yoast_Google_Exception('Cant add services after having authenticated'); 
  53.     } 
  54.     $this->services[$service] = array(); 
  55.     if (isset($apiConfig['services'][$service])) { 
  56.       // Merge the service descriptor with the default values 
  57.       $this->services[$service] = array_merge($this->services[$service], $apiConfig['services'][$service]); 
  58.     } 
  59.   } 
  60.  
  61.   public function authenticate($code = null) { 
  62.     $service = $this->prepareService(); 
  63.     $this->authenticated = true; 
  64.     return self::$auth->authenticate($service, $code); 
  65.   } 
  66.  
  67.   /** 
  68.    * @return array 
  69.    * @visible For Testing 
  70.    */ 
  71.   public function prepareService() { 
  72.     $service = array(); 
  73.     $scopes = array(); 
  74.     if ($this->scopes) { 
  75.       $scopes = $this->scopes; 
  76.     } else { 
  77.       foreach ($this->services as $key => $val) { 
  78.         if (isset($val['scope'])) { 
  79.           if (is_array($val['scope'])) { 
  80.             $scopes = array_merge($val['scope'], $scopes); 
  81.           } else { 
  82.             $scopes[] = $val['scope']; 
  83.           } 
  84.         } else { 
  85.           $scopes[] = 'https://www.googleapis.com/auth/' . $key; 
  86.         } 
  87.         unset($val['discoveryURI']); 
  88.         unset($val['scope']); 
  89.         $service = array_merge($service, $val); 
  90.       } 
  91.     } 
  92.     $service['scope'] = implode(' ', $scopes); 
  93.     return $service; 
  94.   } 
  95.  
  96.   /** 
  97.    * Set the OAuth 2.0 access token using the string that resulted from calling authenticate() 
  98.    * or Yoast_Google_Client#getAccessToken(). 
  99.    * @param string $accessToken JSON encoded string containing in the following format: 
  100.    * {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",  
  101.    *  "expires_in":3600, "id_token":"TOKEN", "created":1320790426} 
  102.    */ 
  103.   public function setAccessToken($accessToken) { 
  104.     if ($accessToken == null || 'null' == $accessToken) { 
  105.       $accessToken = null; 
  106.     } 
  107.     self::$auth->setAccessToken($accessToken); 
  108.   } 
  109.  
  110.   /** 
  111.    * Set the type of Auth class the client should use. 
  112.    * @param string $authClassName 
  113.    */ 
  114.   public function setAuthClass($authClassName) { 
  115.     self::$auth = new $authClassName(); 
  116.   } 
  117.  
  118.   /** 
  119.    * Construct the OAuth 2.0 authorization request URI. 
  120.    * @return string 
  121.    */ 
  122.   public function createAuthUrl() { 
  123.     $service = $this->prepareService(); 
  124.     return self::$auth->createAuthUrl($service['scope']); 
  125.   } 
  126.  
  127.   /** 
  128.    * Get the OAuth 2.0 access token. 
  129.    * @return string $accessToken JSON encoded string in the following format: 
  130.    * {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",  
  131.    *  "expires_in":3600, "id_token":"TOKEN", "created":1320790426} 
  132.    */ 
  133.   public function getAccessToken() { 
  134.     $token = self::$auth->getAccessToken(); 
  135.     return (null == $token || 'null' == $token) ? null : $token; 
  136.   } 
  137.  
  138.   /** 
  139.    * Returns if the access_token is expired. 
  140.    * @return bool Returns True if the access_token is expired. 
  141.    */ 
  142.   public function isAccessTokenExpired() { 
  143.     return self::$auth->isAccessTokenExpired(); 
  144.   } 
  145.  
  146.   /** 
  147.    * Set the developer key to use, these are obtained through the API Console. 
  148.    * @see http://code.google.com/apis/console-help/#generatingdevkeys 
  149.    * @param string $developerKey 
  150.    */ 
  151.   public function setDeveloperKey($developerKey) { 
  152.     self::$auth->setDeveloperKey($developerKey); 
  153.   } 
  154.  
  155.   /** 
  156.    * Set OAuth 2.0 "state" parameter to achieve per-request customization. 
  157.    * @see http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-3.1.2.2 
  158.    * @param string $state 
  159.    */ 
  160.   public function setState($state) { 
  161.     self::$auth->setState($state); 
  162.   } 
  163.  
  164.   /** 
  165.    * @param string $accessType Possible values for access_type include: 
  166.    *  {@code "offline"} to request offline access from the user. (This is the default value) 
  167.    *  {@code "online"} to request online access from the user. 
  168.    */ 
  169.   public function setAccessType($accessType) { 
  170.     self::$auth->setAccessType($accessType); 
  171.   } 
  172.  
  173.   /** 
  174.    * @param string $approvalPrompt Possible values for approval_prompt include: 
  175.    *  {@code "force"} to force the approval UI to appear. (This is the default value) 
  176.    *  {@code "auto"} to request auto-approval when possible. 
  177.    */ 
  178.   public function setApprovalPrompt($approvalPrompt) { 
  179.     self::$auth->setApprovalPrompt($approvalPrompt); 
  180.   } 
  181.  
  182.   /** 
  183.    * Set the application name, this is included in the User-Agent HTTP header. 
  184.    * @param string $applicationName 
  185.    */ 
  186.   public function setApplicationName($applicationName) { 
  187.     global $apiConfig; 
  188.     $apiConfig['application_name'] = $applicationName; 
  189.   } 
  190.  
  191.   /** 
  192.    * Set the OAuth 2.0 Client ID. 
  193.    * @param string $clientId 
  194.    */ 
  195.   public function setClientId($clientId) { 
  196.     global $apiConfig; 
  197.     $apiConfig['oauth2_client_id'] = $clientId; 
  198.     self::$auth->clientId = $clientId; 
  199.   } 
  200.  
  201.   /** 
  202.    * Get the OAuth 2.0 Client ID. 
  203.    */ 
  204.   public function getClientId() { 
  205.     return self::$auth->clientId; 
  206.   } 
  207.  
  208.   /** 
  209.    * Set the OAuth 2.0 Client Secret. 
  210.    * @param string $clientSecret 
  211.    */ 
  212.   public function setClientSecret($clientSecret) { 
  213.     global $apiConfig; 
  214.     $apiConfig['oauth2_client_secret'] = $clientSecret; 
  215.     self::$auth->clientSecret = $clientSecret; 
  216.   } 
  217.  
  218.   /** 
  219.    * Get the OAuth 2.0 Client Secret. 
  220.    */ 
  221.   public function getClientSecret() { 
  222.     return self::$auth->clientSecret; 
  223.   } 
  224.  
  225.   /** 
  226.    * Set the OAuth 2.0 Redirect URI. 
  227.    * @param string $redirectUri 
  228.    */ 
  229.   public function setRedirectUri($redirectUri) { 
  230.     global $apiConfig; 
  231.     $apiConfig['oauth2_redirect_uri'] = $redirectUri; 
  232.     self::$auth->redirectUri = $redirectUri; 
  233.   } 
  234.  
  235.   /** 
  236.    * Get the OAuth 2.0 Redirect URI. 
  237.    */ 
  238.   public function getRedirectUri() { 
  239.     return self::$auth->redirectUri; 
  240.   } 
  241.  
  242.   /** 
  243.    * Fetches a fresh OAuth 2.0 access token with the given refresh token. 
  244.    * @param string $refreshToken 
  245.    * @return void 
  246.    */ 
  247.   public function refreshToken($refreshToken) { 
  248.     self::$auth->refreshToken($refreshToken); 
  249.   } 
  250.  
  251.   /** 
  252.    * Revoke an OAuth2 access token or refresh token. This method will revoke the current access 
  253.    * token, if a token isn't provided. 
  254.    * @throws Yoast_Google_AuthException 
  255.    * @param string|null $token The token (access token or a refresh token) that should be revoked. 
  256.    * @return boolean Returns True if the revocation was successful, otherwise False. 
  257.    */ 
  258.   public function revokeToken($token = null) { 
  259.     self::$auth->revokeToken($token); 
  260.   } 
  261.  
  262.   /** 
  263.    * Verify an id_token. This method will verify the current id_token, if one 
  264.    * isn't provided. 
  265.    * @throws Yoast_Google_AuthException 
  266.    * @param string|null $token The token (id_token) that should be verified. 
  267.    * @return Yoast_Google_LoginTicket Returns an apiLoginTicket if the verification was 
  268.    * successful. 
  269.    */ 
  270.   public function verifyIdToken($token = null) { 
  271.     return self::$auth->verifyIdToken($token); 
  272.   } 
  273.  
  274.   /** 
  275.    * @param Yoast_Google_AssertionCredentials $creds 
  276.    * @return void 
  277.    */ 
  278.   public function setAssertionCredentials(Yoast_Google_AssertionCredentials $creds) { 
  279.     self::$auth->setAssertionCredentials($creds); 
  280.   } 
  281.  
  282.   /** 
  283.    * This function allows you to overrule the automatically generated scopes,  
  284.    * so that you can ask for more or less permission in the auth flow 
  285.    * Set this before you call authenticate() though! 
  286.    * @param array $scopes, ie: array('https://www.googleapis.com/auth/plus.me', 'https://www.googleapis.com/auth/moderator') 
  287.    */ 
  288.   public function setScopes($scopes) { 
  289.     $this->scopes = is_string($scopes) ? explode(" ", $scopes) : $scopes; 
  290.   } 
  291.  
  292.   /** 
  293.    * Returns the list of scopes set on the client 
  294.    * @return array the list of scopes 
  295.    * 
  296.    */ 
  297.   public function getScopes() { 
  298.      return $this->scopes; 
  299.   } 
  300.  
  301.   /** 
  302.    * If 'plus.login' is included in the list of requested scopes, you can use 
  303.    * this method to define types of app activities that your app will write. 
  304.    * You can find a list of available types here: 
  305.    * @link https://developers.google.com/+/api/moment-types 
  306.    * 
  307.    * @param array $requestVisibleActions Array of app activity types 
  308.    */ 
  309.   public function setRequestVisibleActions($requestVisibleActions) { 
  310.     self::$auth->requestVisibleActions = 
  311.             join(" ", $requestVisibleActions); 
  312.   } 
  313.  
  314.   /** 
  315.    * Declare if objects should be returned by the api service classes. 
  316.    * 
  317.    * @param boolean $useObjects True if objects should be returned by the service classes. 
  318.    * False if associative arrays should be returned (default behavior). 
  319.    * @experimental 
  320.    */ 
  321.   public function setUseObjects($useObjects) { 
  322.     global $apiConfig; 
  323.     $apiConfig['use_objects'] = $useObjects; 
  324.   } 
  325.  
  326.   /** 
  327.    * Declare if objects should be returned by the api service classes. 
  328.    * 
  329.    * @param boolean $useBatch True if the experimental batch support should 
  330.    * be enabled. Defaults to False. 
  331.    * @experimental 
  332.    */ 
  333.   public function setUseBatch($useBatch) { 
  334.     self::$useBatch = $useBatch; 
  335.   } 
  336.  
  337.   /** 
  338.    * @static 
  339.    * @return Yoast_Google_Auth the implementation of apiAuth. 
  340.    */ 
  341.   public static function getAuth() { 
  342.     return Yoast_Google_Client::$auth; 
  343.   } 
  344.  
  345.   /** 
  346.    * @static 
  347.    * @return Yoast_Google_IO the implementation of apiIo. 
  348.    */ 
  349.   public static function getIo() { 
  350.     return Yoast_Google_Client::$io; 
  351.   } 
  352.  
  353.   /** 
  354.    * @return Yoast_Google_Cache the implementation of apiCache. 
  355.    */ 
  356.   public function getCache() { 
  357.     return Yoast_Google_Client::$cache; 
  358.   } 
  359. }