mbk-lab
/
nextcloud
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move GDrive external storage to a separate repo 

Signed-off-by: Morris Jobke <hey@morrisjobke.de>
This commit is contained in:
Vincent Petry 2017-03-30 16:08:25 +02:00 committed by Morris Jobke
parent 6e3b8db98d
commit 2cb3461146
147 changed files with 2 additions and 244502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
apps/files_external/3rdparty/google-api-php-client/LICENSE vendored
View File

@ -1,203 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

105
apps/files_external/3rdparty/google-api-php-client/README.md vendored
View File

@ -1,105 +0,0 @@
[![Build Status](https://travis-ci.org/google/google-api-php-client.svg)](https://travis-ci.org/google/google-api-php-client)
# Google APIs Client Library for PHP #
## Description ##
The Google API Client Library enables you to work with Google APIs such as Google+, Drive, or YouTube on your server.
## Beta ##
This library is in Beta. We're comfortable enough with the stability and features of the library that we want you to build real production applications on it. We will make an effort to support the public and protected surface of the library and maintain backwards compatibility in the future. While we are still in Beta, we reserve the right to make incompatible changes. If we do remove some functionality (typically because better functionality exists or if the feature proved infeasible), our intention is to deprecate and provide ample time for developers to update their code.
## Requirements ##
* [PHP 5.2.1 or higher](http://www.php.net/)
* [PHP JSON extension](http://php.net/manual/en/book.json.php)
*Note*: some features (service accounts and id token verification) require PHP 5.3.0 and above due to cryptographic algorithm requirements.
## Developer Documentation ##
http://developers.google.com/api-client-library/php
## Installation ##
For the latest installation and setup instructions, see [the documentation](https://developers.google.com/api-client-library/php/start/installation).
## Basic Example ##
See the examples/ directory for examples of the key client features.
```PHP
<?php
require_once 'google-api-php-client/src/Google/autoload.php'; // or wherever autoload.php is located
$client = new Google_Client();
$client->setApplicationName("Client_Library_Examples");
$client->setDeveloperKey("YOUR_APP_KEY");
$service = new Google_Service_Books($client);
$optParams = array('filter' => 'free-ebooks');
$results = $service->volumes->listVolumes('Henry David Thoreau', $optParams);
foreach ($results as $item) {
echo $item['volumeInfo']['title'], "<br /> \n";
}
```
### Service Specific Examples ###
YouTube: https://github.com/youtube/api-samples/tree/master/php
## Frequently Asked Questions ##
### What do I do if something isn't working? ###
For support with the library the best place to ask is via the google-api-php-client tag on StackOverflow: http://stackoverflow.com/questions/tagged/google-api-php-client
If there is a specific bug with the library, please file a issue in the Github issues tracker, including a (minimal) example of the failing code and any specific errors retrieved. Feature requests can also be filed, as long as they are core library requests, and not-API specific: for those, refer to the documentation for the individual APIs for the best place to file requests. Please try to provide a clear statement of the problem that the feature would address.
### How do I contribute? ###
We accept contributions via Github Pull Requests, but all contributors need to be covered by the standard Google Contributor License Agreement. You can find links, and more instructions, in the documentation: https://developers.google.com/api-client-library/php/contribute
### I want an example of X! ###
If X is a feature of the library, file away! If X is an example of using a specific service, the best place to go is to the teams for those specific APIs - our preference is to link to their examples rather than add them to the library, as they can then pin to specific versions of the library. If you have any examples for other APIs, let us know and we will happily add a link to the README above!
### Why do you still support 5.2? ###
When we started working on the 1.0.0 branch we knew there were several fundamental issues to fix with the 0.6 releases of the library. At that time we looked at the usage of the library, and other related projects, and determined that there was still a large and active base of PHP 5.2 installs. You can see this in statistics such as the PHP versions chart in the WordPress stats: http://wordpress.org/about/stats/. We will keep looking at the types of usage we see, and try to take advantage of newer PHP features where possible.
### Why does Google_..._Service have weird names? ###
The _Service classes are generally automatically generated from the API discovery documents: https://developers.google.com/discovery/. Sometimes new features are added to APIs with unusual names, which can cause some unexpected or non-standard style naming in the PHP classes.
### How do I deal with non-JSON response types? ###
Some services return XML or similar by default, rather than JSON, which is what the library supports. You can request a JSON response by adding an 'alt' argument to optional params that is normally the last argument to a method call:
```
$opt_params = array(
'alt' => "json"
);
```
### How do I set a field to null? ###
The library strips out nulls from the objects sent to the Google APIs as its the default value of all of the uninitialised properties. To work around this, set the field you want to null to Google_Model::NULL_VALUE. This is a placeholder that will be replaced with a true null when sent over the wire.
## Code Quality ##
Run the PHPUnit tests with PHPUnit. You can configure an API key and token in BaseTest.php to run all calls, but this will require some setup on the Google Developer Console.
phpunit tests/
### Coding Style
To check for coding style violations, run
```
vendor/bin/phpcs src --standard=style/ruleset.xml -np
```
To automatically fix (fixable) coding style violations, run
```
vendor/bin/phpcbf src --standard=style/ruleset.xml
```

38
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/Abstract.php vendored
View File

@ -1,38 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Abstract class for the Authentication in the API client
* @author Chris Chabot <chabotc@google.com>
*
*/
abstract class Google_Auth_Abstract
{
/**
* An utility function that first calls $this->auth->sign($request) and then
* executes makeRequest() on that signed request. Used for when a request
* should be authenticated
* @param Google_Http_Request $request
* @return Google_Http_Request $request
*/
abstract public function authenticatedRequest(Google_Http_Request $request);
abstract public function sign(Google_Http_Request $request);
}

120
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/AppIdentity.php vendored
View File

@ -1,120 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* WARNING - this class depends on the Google App Engine PHP library
* which is 5.3 and above only, so if you include this in a PHP 5.2
* setup or one without 5.3 things will blow up.
*/
use google\appengine\api\app_identity\AppIdentityService;
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Authentication via the Google App Engine App Identity service.
*/
class Google_Auth_AppIdentity extends Google_Auth_Abstract
{
const CACHE_PREFIX = "Google_Auth_AppIdentity::";
private $client;
private $token = false;
private $tokenScopes = false;
public function __construct(Google_Client $client, $config = null)
{
$this->client = $client;
}
/**
* Retrieve an access token for the scopes supplied.
*/
public function authenticateForScope($scopes)
{
if ($this->token && $this->tokenScopes == $scopes) {
return $this->token;
}
$cacheKey = self::CACHE_PREFIX;
if (is_string($scopes)) {
$cacheKey .= $scopes;
} else if (is_array($scopes)) {
$cacheKey .= implode(":", $scopes);
}
$this->token = $this->client->getCache()->get($cacheKey);
if (!$this->token) {
$this->retrieveToken($scopes, $cacheKey);
} else if ($this->token['expiration_time'] < time()) {
$this->client->getCache()->delete($cacheKey);
$this->retrieveToken($scopes, $cacheKey);
}
$this->tokenScopes = $scopes;
return $this->token;
}
/**
* Retrieve a new access token and store it in cache
* @param mixed $scopes
* @param string $cacheKey
*/
private function retrieveToken($scopes, $cacheKey)
{
$this->token = AppIdentityService::getAccessToken($scopes);
if ($this->token) {
$this->client->getCache()->set(
$cacheKey,
$this->token
);
}
}
/**
* Perform an authenticated / signed apiHttpRequest.
* This function takes the apiHttpRequest, calls apiAuth->sign on it
* (which can modify the request in what ever way fits the auth mechanism)
* and then calls apiCurlIO::makeRequest on the signed request
*
* @param Google_Http_Request $request
* @return Google_Http_Request The resulting HTTP response including the
* responseHttpCode, responseHeaders and responseBody.
*/
public function authenticatedRequest(Google_Http_Request $request)
{
$request = $this->sign($request);
return $this->client->getIo()->makeRequest($request);
}
public function sign(Google_Http_Request $request)
{
if (!$this->token) {
// No token, so nothing to do.
return $request;
}
$this->client->getLogger()->debug('App Identity authentication');
// Add the OAuth2 header to the request
$request->setRequestHeaders(
array('Authorization' => 'Bearer ' . $this->token['access_token'])
);
return $request;
}
}

136
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/AssertionCredentials.php vendored
View File

@ -1,136 +0,0 @@
<?php
/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Credentials object used for OAuth 2.0 Signed JWT assertion grants.
*/
class Google_Auth_AssertionCredentials
{
const MAX_TOKEN_LIFETIME_SECS = 3600;
public $serviceAccountName;
public $scopes;
public $privateKey;
public $privateKeyPassword;
public $assertionType;
public $sub;
/**
* @deprecated
* @link http://tools.ietf.org/html/draft-ietf-oauth-json-web-token-06
*/
public $prn;
private $useCache;
/**
* @param $serviceAccountName
* @param $scopes array List of scopes
* @param $privateKey
* @param string $privateKeyPassword
* @param string $assertionType
* @param bool|string $sub The email address of the user for which the
* application is requesting delegated access.
* @param bool useCache Whether to generate a cache key and allow
* automatic caching of the generated token.
*/
public function __construct(
$serviceAccountName,
$scopes,
$privateKey,
$privateKeyPassword = 'notasecret',
$assertionType = 'http://oauth.net/grant_type/jwt/1.0/bearer',
$sub = false,
$useCache = true
) {
$this->serviceAccountName = $serviceAccountName;
$this->scopes = is_string($scopes) ? $scopes : implode(' ', $scopes);
$this->privateKey = $privateKey;
$this->privateKeyPassword = $privateKeyPassword;
$this->assertionType = $assertionType;
$this->sub = $sub;
$this->prn = $sub;
$this->useCache = $useCache;
}
/**
* Generate a unique key to represent this credential.
* @return string
*/
public function getCacheKey()
{
if (!$this->useCache) {
return false;
}
$h = $this->sub;
$h .= $this->assertionType;
$h .= $this->privateKey;
$h .= $this->scopes;
$h .= $this->serviceAccountName;
return md5($h);
}
public function generateAssertion()
{
$now = time();
$jwtParams = array(
'aud' => Google_Auth_OAuth2::OAUTH2_TOKEN_URI,
'scope' => $this->scopes,
'iat' => $now,
'exp' => $now + self::MAX_TOKEN_LIFETIME_SECS,
'iss' => $this->serviceAccountName,
);
if ($this->sub !== false) {
$jwtParams['sub'] = $this->sub;
} else if ($this->prn !== false) {
$jwtParams['prn'] = $this->prn;
}
return $this->makeSignedJwt($jwtParams);
}
/**
* Creates a signed JWT.
* @param array $payload
* @return string The signed JWT.
*/
private function makeSignedJwt($payload)
{
$header = array('typ' => 'JWT', 'alg' => 'RS256');
$payload = json_encode($payload);
// Handle some overzealous escaping in PHP json that seemed to cause some errors
// with claimsets.
$payload = str_replace('\/', '/', $payload);
$segments = array(
Google_Utils::urlSafeB64Encode(json_encode($header)),
Google_Utils::urlSafeB64Encode($payload)
);
$signingInput = implode('.', $segments);
$signer = new Google_Signer_P12($this->privateKey, $this->privateKeyPassword);
$signature = $signer->sign($signingInput);
$segments[] = Google_Utils::urlSafeB64Encode($signature);
return implode(".", $segments);
}
}

146
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/ComputeEngine.php vendored
View File

@ -1,146 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Authentication via built-in Compute Engine service accounts.
* The instance must be pre-configured with a service account
* and the appropriate scopes.
* @author Jonathan Parrott <jon.wayne.parrott@gmail.com>
*/
class Google_Auth_ComputeEngine extends Google_Auth_Abstract
{
const METADATA_AUTH_URL =
'http://metadata/computeMetadata/v1/instance/service-accounts/default/token';
private $client;
private $token;
public function __construct(Google_Client $client, $config = null)
{
$this->client = $client;
}
/**
* Perform an authenticated / signed apiHttpRequest.
* This function takes the apiHttpRequest, calls apiAuth->sign on it
* (which can modify the request in what ever way fits the auth mechanism)
* and then calls apiCurlIO::makeRequest on the signed request
*
* @param Google_Http_Request $request
* @return Google_Http_Request The resulting HTTP response including the
* responseHttpCode, responseHeaders and responseBody.
*/
public function authenticatedRequest(Google_Http_Request $request)
{
$request = $this->sign($request);
return $this->client->getIo()->makeRequest($request);
}
/**
* @param string $token
* @throws Google_Auth_Exception
*/
public function setAccessToken($token)
{
$token = json_decode($token, true);
if ($token == null) {
throw new Google_Auth_Exception('Could not json decode the token');
}
if (! isset($token['access_token'])) {
throw new Google_Auth_Exception("Invalid token format");
}
$token['created'] = time();
$this->token = $token;
}
public function getAccessToken()
{
return json_encode($this->token);
}
/**
* Acquires a new access token from the compute engine metadata server.
* @throws Google_Auth_Exception
*/
public function acquireAccessToken()
{
$request = new Google_Http_Request(
self::METADATA_AUTH_URL,
'GET',
array(
'Metadata-Flavor' => 'Google'
)
);
$request->disableGzip();
$response = $this->client->getIo()->makeRequest($request);
if ($response->getResponseHttpCode() == 200) {
$this->setAccessToken($response->getResponseBody());
$this->token['created'] = time();
return $this->getAccessToken();
} else {
throw new Google_Auth_Exception(
sprintf(
"Error fetching service account access token, message: '%s'",
$response->getResponseBody()
),
$response->getResponseHttpCode()
);
}
}
/**
* Include an accessToken in a given apiHttpRequest.
* @param Google_Http_Request $request
* @return Google_Http_Request
* @throws Google_Auth_Exception
*/
public function sign(Google_Http_Request $request)
{
if ($this->isAccessTokenExpired()) {
$this->acquireAccessToken();
}
$this->client->getLogger()->debug('Compute engine service account authentication');
$request->setRequestHeaders(
array('Authorization' => 'Bearer ' . $this->token['access_token'])
);
return $request;
}
/**
* Returns if the access_token is expired.
* @return bool Returns True if the access_token is expired.
*/
public function isAccessTokenExpired()
{
if (!$this->token || !isset($this->token['created'])) {
return true;
}
// If the token is set to expire in the next 30 seconds.
$expired = ($this->token['created']
+ ($this->token['expires_in'] - 30)) < time();
return $expired;
}
}

24
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/Exception.php vendored
View File

@ -1,24 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_Auth_Exception extends Google_Exception
{
}

71
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/LoginTicket.php vendored
View File

@ -1,71 +0,0 @@
<?php
/*
* Copyright 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Class to hold information about an authenticated login.
*
* @author Brian Eaton <beaton@google.com>
*/
class Google_Auth_LoginTicket
{
const USER_ATTR = "sub";
// Information from id token envelope.
private $envelope;
// Information from id token payload.
private $payload;
/**
* Creates a user based on the supplied token.
*
* @param string $envelope Header from a verified authentication token.
* @param string $payload Information from a verified authentication token.
*/
public function __construct($envelope, $payload)
{
$this->envelope = $envelope;
$this->payload = $payload;
}
/**
* Returns the numeric identifier for the user.
* @throws Google_Auth_Exception
* @return
*/
public function getUserId()
{
if (array_key_exists(self::USER_ATTR, $this->payload)) {
return $this->payload[self::USER_ATTR];
}
throw new Google_Auth_Exception("No user_id in token");
}
/**
* Returns attributes from the login ticket. This can contain
* various information about the user session.
* @return array
*/
public function getAttributes()
{
return array("envelope" => $this->envelope, "payload" => $this->payload);
}
}

646
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/OAuth2.php vendored
View File

@ -1,646 +0,0 @@
<?php
/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Authentication class that deals with the OAuth 2 web-server authentication flow
*
*/
class Google_Auth_OAuth2 extends Google_Auth_Abstract
{
const OAUTH2_REVOKE_URI = 'https://accounts.google.com/o/oauth2/revoke';
const OAUTH2_TOKEN_URI = 'https://accounts.google.com/o/oauth2/token';
const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';
const CLOCK_SKEW_SECS = 300; // five minutes in seconds
const AUTH_TOKEN_LIFETIME_SECS = 300; // five minutes in seconds
const MAX_TOKEN_LIFETIME_SECS = 86400; // one day in seconds
const OAUTH2_ISSUER = 'accounts.google.com';
const OAUTH2_ISSUER_HTTPS = 'https://accounts.google.com';
/** @var Google_Auth_AssertionCredentials $assertionCredentials */
private $assertionCredentials;
/**
* @var string The state parameters for CSRF and other forgery protection.
*/
private $state;
/**
* @var array The token bundle.
*/
private $token = array();
/**
* @var Google_Client the base client
*/
private $client;
/**
* Instantiates the class, but does not initiate the login flow, leaving it
* to the discretion of the caller.
*/
public function __construct(Google_Client $client)
{
$this->client = $client;
}
/**
* Perform an authenticated / signed apiHttpRequest.
* This function takes the apiHttpRequest, calls apiAuth->sign on it
* (which can modify the request in what ever way fits the auth mechanism)
* and then calls apiCurlIO::makeRequest on the signed request
*
* @param Google_Http_Request $request
* @return Google_Http_Request The resulting HTTP response including the
* responseHttpCode, responseHeaders and responseBody.
*/
public function authenticatedRequest(Google_Http_Request $request)
{
$request = $this->sign($request);
return $this->client->getIo()->makeRequest($request);
}
/**
* @param string $code
* @param boolean $crossClient
* @throws Google_Auth_Exception
* @return string
*/
public function authenticate($code, $crossClient = false)
{
if (strlen($code) == 0) {
throw new Google_Auth_Exception("Invalid code");
}
$arguments = array(
'code' => $code,
'grant_type' => 'authorization_code',
'client_id' => $this->client->getClassConfig($this, 'client_id'),
'client_secret' => $this->client->getClassConfig($this, 'client_secret')
);
if ($crossClient !== true) {
$arguments['redirect_uri'] = $this->client->getClassConfig($this, 'redirect_uri');
}
// We got here from the redirect from a successful authorization grant,
// fetch the access token
$request = new Google_Http_Request(
self::OAUTH2_TOKEN_URI,
'POST',
array(),
$arguments
);
$request->disableGzip();
$response = $this->client->getIo()->makeRequest($request);
if ($response->getResponseHttpCode() == 200) {
$this->setAccessToken($response->getResponseBody());
$this->token['created'] = time();
return $this->getAccessToken();
} else {
$decodedResponse = json_decode($response->getResponseBody(), true);
if ($decodedResponse != null && $decodedResponse['error']) {
$errorText = $decodedResponse['error'];
if (isset($decodedResponse['error_description'])) {
$errorText .= ": " . $decodedResponse['error_description'];
}
}
throw new Google_Auth_Exception(
sprintf(
"Error fetching OAuth2 access token, message: '%s'",
$errorText
),
$response->getResponseHttpCode()
);
}
}
/**
* Create a URL to obtain user authorization.
* The authorization endpoint allows the user to first
* authenticate, and then grant/deny the access request.
* @param string $scope The scope is expressed as a list of space-delimited strings.
* @return string
*/
public function createAuthUrl($scope)
{
$params = array(
'response_type' => 'code',
'redirect_uri' => $this->client->getClassConfig($this, 'redirect_uri'),
'client_id' => $this->client->getClassConfig($this, 'client_id'),
'scope' => $scope,
'access_type' => $this->client->getClassConfig($this, 'access_type'),
);
// Prefer prompt to approval prompt.
if ($this->client->getClassConfig($this, 'prompt')) {
$params = $this->maybeAddParam($params, 'prompt');
} else {
$params = $this->maybeAddParam($params, 'approval_prompt');
}
$params = $this->maybeAddParam($params, 'login_hint');
$params = $this->maybeAddParam($params, 'hd');
$params = $this->maybeAddParam($params, 'openid.realm');
$params = $this->maybeAddParam($params, 'include_granted_scopes');
// If the list of scopes contains plus.login, add request_visible_actions
// to auth URL.
$rva = $this->client->getClassConfig($this, 'request_visible_actions');
if (strpos($scope, 'plus.login') && strlen($rva) > 0) {
$params['request_visible_actions'] = $rva;
}
if (isset($this->state)) {
$params['state'] = $this->state;
}
return self::OAUTH2_AUTH_URL . "?" . http_build_query($params, '', '&');
}
/**
* @param string $token
* @throws Google_Auth_Exception
*/
public function setAccessToken($token)
{
$token = json_decode($token, true);
if ($token == null) {
throw new Google_Auth_Exception('Could not json decode the token');
}
if (! isset($token['access_token'])) {
throw new Google_Auth_Exception("Invalid token format");
}
$this->token = $token;
}
public function getAccessToken()
{
return json_encode($this->token);
}
public function getRefreshToken()
{
if (array_key_exists('refresh_token', $this->token)) {
return $this->token['refresh_token'];
} else {
return null;
}
}
public function setState($state)
{
$this->state = $state;
}
public function setAssertionCredentials(Google_Auth_AssertionCredentials $creds)
{
$this->assertionCredentials = $creds;
}
/**
* Include an accessToken in a given apiHttpRequest.
* @param Google_Http_Request $request
* @return Google_Http_Request
* @throws Google_Auth_Exception
*/
public function sign(Google_Http_Request $request)
{
// add the developer key to the request before signing it
if ($this->client->getClassConfig($this, 'developer_key')) {
$request->setQueryParam('key', $this->client->getClassConfig($this, 'developer_key'));
}
// Cannot sign the request without an OAuth access token.
if (null == $this->token && null == $this->assertionCredentials) {
return $request;
}
// Check if the token is set to expire in the next 30 seconds
// (or has already expired).
if ($this->isAccessTokenExpired()) {
if ($this->assertionCredentials) {
$this->refreshTokenWithAssertion();
} else {
$this->client->getLogger()->debug('OAuth2 access token expired');
if (! array_key_exists('refresh_token', $this->token)) {
$error = "The OAuth 2.0 access token has expired,"
." and a refresh token is not available. Refresh tokens"
." are not returned for responses that were auto-approved.";
$this->client->getLogger()->error($error);
throw new Google_Auth_Exception($error);
}
$this->refreshToken($this->token['refresh_token']);
}
}
$this->client->getLogger()->debug('OAuth2 authentication');
// Add the OAuth2 header to the request
$request->setRequestHeaders(
array('Authorization' => 'Bearer ' . $this->token['access_token'])
);
return $request;
}
/**
* Fetches a fresh access token with the given refresh token.
* @param string $refreshToken
* @return void
*/
public function refreshToken($refreshToken)
{
$this->refreshTokenRequest(
array(
'client_id' => $this->client->getClassConfig($this, 'client_id'),
'client_secret' => $this->client->getClassConfig($this, 'client_secret'),
'refresh_token' => $refreshToken,
'grant_type' => 'refresh_token'
)
);
}
/**
* Fetches a fresh access token with a given assertion token.
* @param Google_Auth_AssertionCredentials $assertionCredentials optional.
* @return void
*/
public function refreshTokenWithAssertion($assertionCredentials = null)
{
if (!$assertionCredentials) {
$assertionCredentials = $this->assertionCredentials;
}
$cacheKey = $assertionCredentials->getCacheKey();
if ($cacheKey) {
// We can check whether we have a token available in the
// cache. If it is expired, we can retrieve a new one from
// the assertion.
$token = $this->client->getCache()->get($cacheKey);
if ($token) {
$this->setAccessToken($token);
}
if (!$this->isAccessTokenExpired()) {
return;
}
}
$this->client->getLogger()->debug('OAuth2 access token expired');
$this->refreshTokenRequest(
array(
'grant_type' => 'assertion',
'assertion_type' => $assertionCredentials->assertionType,
'assertion' => $assertionCredentials->generateAssertion(),
)
);
if ($cacheKey) {
// Attempt to cache the token.
$this->client->getCache()->set(
$cacheKey,
$this->getAccessToken()
);
}
}
private function refreshTokenRequest($params)
{
if (isset($params['assertion'])) {
$this->client->getLogger()->info(
'OAuth2 access token refresh with Signed JWT assertion grants.'
);
} else {
$this->client->getLogger()->info('OAuth2 access token refresh');
}
$http = new Google_Http_Request(
self::OAUTH2_TOKEN_URI,
'POST',
array(),
$params
);
$http->disableGzip();
$request = $this->client->getIo()->makeRequest($http);
$code = $request->getResponseHttpCode();
$body = $request->getResponseBody();
if (200 == $code) {
$token = json_decode($body, true);
if ($token == null) {
throw new Google_Auth_Exception("Could not json decode the access token");
}
if (! isset($token['access_token']) || ! isset($token['expires_in'])) {
throw new Google_Auth_Exception("Invalid token format");
}
if (isset($token['id_token'])) {
$this->token['id_token'] = $token['id_token'];
}
$this->token['access_token'] = $token['access_token'];
$this->token['expires_in'] = $token['expires_in'];
$this->token['created'] = time();
} else {
throw new Google_Auth_Exception("Error refreshing the OAuth2 token, message: '$body'", $code);
}
}
/**
* Revoke an OAuth2 access token or refresh token. This method will revoke the current access
* token, if a token isn't provided.
* @throws Google_Auth_Exception
* @param string|null $token The token (access token or a refresh token) that should be revoked.
* @return boolean Returns True if the revocation was successful, otherwise False.
*/
public function revokeToken($token = null)
{
if (!$token) {
if (!$this->token) {
// Not initialized, no token to actually revoke
return false;
} elseif (array_key_exists('refresh_token', $this->token)) {
$token = $this->token['refresh_token'];
} else {
$token = $this->token['access_token'];
}
}
$request = new Google_Http_Request(
self::OAUTH2_REVOKE_URI,
'POST',
array(),
"token=$token"
);
$request->disableGzip();
$response = $this->client->getIo()->makeRequest($request);
$code = $response->getResponseHttpCode();
if ($code == 200) {
$this->token = null;
return true;
}
return false;
}
/**
* Returns if the access_token is expired.
* @return bool Returns True if the access_token is expired.
*/
public function isAccessTokenExpired()
{
if (!$this->token || !isset($this->token['created'])) {
return true;
}
// If the token is set to expire in the next 30 seconds.
$expired = ($this->token['created']
+ ($this->token['expires_in'] - 30)) < time();
return $expired;
}
// Gets federated sign-on certificates to use for verifying identity tokens.
// Returns certs as array structure, where keys are key ids, and values
// are PEM encoded certificates.
private function getFederatedSignOnCerts()
{
return $this->retrieveCertsFromLocation(
$this->client->getClassConfig($this, 'federated_signon_certs_url')
);
}
/**
* Retrieve and cache a certificates file.
*
* @param $url string location
* @throws Google_Auth_Exception
* @return array certificates
*/
public function retrieveCertsFromLocation($url)
{
// If we're retrieving a local file, just grab it.
if ("http" != substr($url, 0, 4)) {
$file = file_get_contents($url);
if ($file) {
return json_decode($file, true);
} else {
throw new Google_Auth_Exception(
"Failed to retrieve verification certificates: '" .
$url . "'."
);
}
}
// This relies on makeRequest caching certificate responses.
$request = $this->client->getIo()->makeRequest(
new Google_Http_Request(
$url
)
);
if ($request->getResponseHttpCode() == 200) {
$certs = json_decode($request->getResponseBody(), true);
if ($certs) {
return $certs;
}
}
throw new Google_Auth_Exception(
"Failed to retrieve verification certificates: '" .
$request->getResponseBody() . "'.",
$request->getResponseHttpCode()
);
}
/**
* Verifies an id token and returns the authenticated apiLoginTicket.
* Throws an exception if the id token is not valid.
* The audience parameter can be used to control which id tokens are
* accepted. By default, the id token must have been issued to this OAuth2 client.
*
* @param $id_token
* @param $audience
* @return Google_Auth_LoginTicket
*/
public function verifyIdToken($id_token = null, $audience = null)
{
if (!$id_token) {
$id_token = $this->token['id_token'];
}
$certs = $this->getFederatedSignonCerts();
if (!$audience) {
$audience = $this->client->getClassConfig($this, 'client_id');
}
return $this->verifySignedJwtWithCerts(
$id_token,
$certs,
$audience,
array(self::OAUTH2_ISSUER, self::OAUTH2_ISSUER_HTTPS)
);
}
/**
* Verifies the id token, returns the verified token contents.
*
* @param $jwt string the token
* @param $certs array of certificates
* @param $required_audience string the expected consumer of the token
* @param [$issuer] the expected issues, defaults to Google
* @param [$max_expiry] the max lifetime of a token, defaults to MAX_TOKEN_LIFETIME_SECS
* @throws Google_Auth_Exception
* @return mixed token information if valid, false if not
*/
public function verifySignedJwtWithCerts(
$jwt,
$certs,
$required_audience,
$issuer = null,
$max_expiry = null
) {
if (!$max_expiry) {
// Set the maximum time we will accept a token for.
$max_expiry = self::MAX_TOKEN_LIFETIME_SECS;
}
$segments = explode(".", $jwt);
if (count($segments) != 3) {
throw new Google_Auth_Exception("Wrong number of segments in token: $jwt");
}
$signed = $segments[0] . "." . $segments[1];
$signature = Google_Utils::urlSafeB64Decode($segments[2]);
// Parse envelope.
$envelope = json_decode(Google_Utils::urlSafeB64Decode($segments[0]), true);
if (!$envelope) {
throw new Google_Auth_Exception("Can't parse token envelope: " . $segments[0]);
}
// Parse token
$json_body = Google_Utils::urlSafeB64Decode($segments[1]);
$payload = json_decode($json_body, true);
if (!$payload) {
throw new Google_Auth_Exception("Can't parse token payload: " . $segments[1]);
}
// Check signature
$verified = false;
foreach ($certs as $keyName => $pem) {
$public_key = new Google_Verifier_Pem($pem);
if ($public_key->verify($signed, $signature)) {
$verified = true;
break;
}
}
if (!$verified) {
throw new Google_Auth_Exception("Invalid token signature: $jwt");
}
// Check issued-at timestamp
$iat = 0;
if (array_key_exists("iat", $payload)) {
$iat = $payload["iat"];
}
if (!$iat) {
throw new Google_Auth_Exception("No issue time in token: $json_body");
}
$earliest = $iat - self::CLOCK_SKEW_SECS;
// Check expiration timestamp
$now = time();
$exp = 0;
if (array_key_exists("exp", $payload)) {
$exp = $payload["exp"];
}
if (!$exp) {
throw new Google_Auth_Exception("No expiration time in token: $json_body");
}
if ($exp >= $now + $max_expiry) {
throw new Google_Auth_Exception(
sprintf("Expiration time too far in future: %s", $json_body)
);
}
$latest = $exp + self::CLOCK_SKEW_SECS;
if ($now < $earliest) {
throw new Google_Auth_Exception(
sprintf(
"Token used too early, %s < %s: %s",
$now,
$earliest,
$json_body
)
);
}
if ($now > $latest) {
throw new Google_Auth_Exception(
sprintf(
"Token used too late, %s > %s: %s",
$now,
$latest,
$json_body
)
);
}
// support HTTP and HTTPS issuers
// @see https://developers.google.com/identity/sign-in/web/backend-auth
$iss = $payload['iss'];
if ($issuer && !in_array($iss, (array) $issuer)) {
throw new Google_Auth_Exception(
sprintf(
"Invalid issuer, %s not in %s: %s",
$iss,
"[".implode(",", (array) $issuer)."]",
$json_body
)
);
}
// Check audience
$aud = $payload["aud"];
if ($aud != $required_audience) {
throw new Google_Auth_Exception(
sprintf(
"Wrong recipient, %s != %s:",
$aud,
$required_audience,
$json_body
)
);
}
// All good.
return new Google_Auth_LoginTicket($envelope, $payload);
}
/**
* Add a parameter to the auth params if not empty string.
*/
private function maybeAddParam($params, $name)
{
$param = $this->client->getClassConfig($this, $name);
if ($param != '') {
$params[$name] = $param;
}
return $params;
}
}

63
apps/files_external/3rdparty/google-api-php-client/src/Google/Auth/Simple.php vendored
View File

@ -1,63 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Simple API access implementation. Can either be used to make requests
* completely unauthenticated, or by using a Simple API Access developer
* key.
*/
class Google_Auth_Simple extends Google_Auth_Abstract
{
private $client;
public function __construct(Google_Client $client, $config = null)
{
$this->client = $client;
}
/**
* Perform an authenticated / signed apiHttpRequest.
* This function takes the apiHttpRequest, calls apiAuth->sign on it
* (which can modify the request in what ever way fits the auth mechanism)
* and then calls apiCurlIO::makeRequest on the signed request
*
* @param Google_Http_Request $request
* @return Google_Http_Request The resulting HTTP response including the
* responseHttpCode, responseHeaders and responseBody.
*/
public function authenticatedRequest(Google_Http_Request $request)
{
$request = $this->sign($request);
return $this->io->makeRequest($request);
}
public function sign(Google_Http_Request $request)
{
$key = $this->client->getClassConfig($this, 'developer_key');
if ($key) {
$this->client->getLogger()->debug(
'Simple API Access developer key authentication'
);
$request->setQueryParam('key', $key);
}
return $request;
}
}

53
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/Abstract.php vendored
View File

@ -1,53 +0,0 @@
<?php
/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Abstract storage class
*
* @author Chris Chabot <chabotc@google.com>
*/
abstract class Google_Cache_Abstract
{
abstract public function __construct(Google_Client $client);
/**
* Retrieves the data for the given key, or false if they
* key is unknown or expired
*
* @param String $key The key who's data to retrieve
* @param boolean|int $expiration Expiration time in seconds
*
*/
abstract public function get($key, $expiration = false);
/**
* Store the key => $value set. The $value is serialized
* by this function so can be of any type
*
* @param string $key Key of the data
* @param string $value data
*/
abstract public function set($key, $value);
/**
* Removes the key/data pair for the given $key
*
* @param String $key
*/
abstract public function delete($key);
}

113
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/Apc.php vendored
View File

@ -1,113 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* A persistent storage class based on the APC cache, which is not
* really very persistent, as soon as you restart your web server
* the storage will be wiped, however for debugging and/or speed
* it can be useful, and cache is a lot cheaper then storage.
*
* @author Chris Chabot <chabotc@google.com>
*/
class Google_Cache_Apc extends Google_Cache_Abstract
{
/**
* @var Google_Client the current client
*/
private $client;
public function __construct(Google_Client $client)
{
if (! function_exists('apc_add') ) {
$error = "Apc functions not available";
$client->getLogger()->error($error);
throw new Google_Cache_Exception($error);
}
$this->client = $client;
}
/**
* @inheritDoc
*/
public function get($key, $expiration = false)
{
$ret = apc_fetch($key);
if ($ret === false) {
$this->client->getLogger()->debug(
'APC cache miss',
array('key' => $key)
);
return false;
}
if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
$this->client->getLogger()->debug(
'APC cache miss (expired)',
array('key' => $key, 'var' => $ret)
);
$this->delete($key);
return false;
}
$this->client->getLogger()->debug(
'APC cache hit',
array('key' => $key, 'var' => $ret)
);
return $ret['data'];
}
/**
* @inheritDoc
*/
public function set($key, $value)
{
$var = array('time' => time(), 'data' => $value);
$rc = apc_store($key, $var);
if ($rc == false) {
$this->client->getLogger()->error(
'APC cache set failed',
array('key' => $key, 'var' => $var)
);
throw new Google_Cache_Exception("Couldn't store data");
}
$this->client->getLogger()->debug(
'APC cache set',
array('key' => $key, 'var' => $var)
);
}
/**
* @inheritDoc
* @param String $key
*/
public function delete($key)
{
$this->client->getLogger()->debug(
'APC cache delete',
array('key' => $key)
);
apc_delete($key);
}
}

24
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/Exception.php vendored
View File

@ -1,24 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_Cache_Exception extends Google_Exception
{
}

209
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/File.php vendored
View File

@ -1,209 +0,0 @@
<?php
/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/*
* This class implements a basic on disk storage. While that does
* work quite well it's not the most elegant and scalable solution.
* It will also get you into a heap of trouble when you try to run
* this in a clustered environment.
*
* @author Chris Chabot <chabotc@google.com>
*/
class Google_Cache_File extends Google_Cache_Abstract
{
const MAX_LOCK_RETRIES = 10;
private $path;
private $fh;
/**
* @var Google_Client the current client
*/
private $client;
public function __construct(Google_Client $client)
{
$this->client = $client;
$this->path = $this->client->getClassConfig($this, 'directory');
}
public function get($key, $expiration = false)
{
$storageFile = $this->getCacheFile($key);
$data = false;
if (!file_exists($storageFile)) {
$this->client->getLogger()->debug(
'File cache miss',
array('key' => $key, 'file' => $storageFile)
);
return false;
}
if ($expiration) {
$mtime = filemtime($storageFile);
if ((time() - $mtime) >= $expiration) {
$this->client->getLogger()->debug(
'File cache miss (expired)',
array('key' => $key, 'file' => $storageFile)
);
$this->delete($key);
return false;
}
}
if ($this->acquireReadLock($storageFile)) {
if (filesize($storageFile) > 0) {
$data = fread($this->fh, filesize($storageFile));
$data = unserialize($data);
} else {
$this->client->getLogger()->debug(
'Cache file was empty',
array('file' => $storageFile)
);
}
$this->unlock($storageFile);
}
$this->client->getLogger()->debug(
'File cache hit',
array('key' => $key, 'file' => $storageFile, 'var' => $data)
);
return $data;
}
public function set($key, $value)
{
$storageFile = $this->getWriteableCacheFile($key);
if ($this->acquireWriteLock($storageFile)) {
// We serialize the whole request object, since we don't only want the
// responseContent but also the postBody used, headers, size, etc.
$data = serialize($value);
$result = fwrite($this->fh, $data);
$this->unlock($storageFile);
$this->client->getLogger()->debug(
'File cache set',
array('key' => $key, 'file' => $storageFile, 'var' => $value)
);
} else {
$this->client->getLogger()->notice(
'File cache set failed',
array('key' => $key, 'file' => $storageFile)
);
}
}
public function delete($key)
{
$file = $this->getCacheFile($key);
if (file_exists($file) && !unlink($file)) {
$this->client->getLogger()->error(
'File cache delete failed',
array('key' => $key, 'file' => $file)
);
throw new Google_Cache_Exception("Cache file could not be deleted");
}
$this->client->getLogger()->debug(
'File cache delete',
array('key' => $key, 'file' => $file)
);
}
private function getWriteableCacheFile($file)
{
return $this->getCacheFile($file, true);
}
private function getCacheFile($file, $forWrite = false)
{
return $this->getCacheDir($file, $forWrite) . '/' . md5($file);
}
private function getCacheDir($file, $forWrite)
{
// use the first 2 characters of the hash as a directory prefix
// this should prevent slowdowns due to huge directory listings
// and thus give some basic amount of scalability
$storageDir = $this->path . '/' . substr(md5($file), 0, 2);
if ($forWrite && ! is_dir($storageDir)) {
if (! mkdir($storageDir, 0700, true)) {
$this->client->getLogger()->error(
'File cache creation failed',
array('dir' => $storageDir)
);
throw new Google_Cache_Exception("Could not create storage directory: $storageDir");
}
}
return $storageDir;
}
private function acquireReadLock($storageFile)
{
return $this->acquireLock(LOCK_SH, $storageFile);
}
private function acquireWriteLock($storageFile)
{
$rc = $this->acquireLock(LOCK_EX, $storageFile);
if (!$rc) {
$this->client->getLogger()->notice(
'File cache write lock failed',
array('file' => $storageFile)
);
$this->delete($storageFile);
}
return $rc;
}
private function acquireLock($type, $storageFile)
{
$mode = $type == LOCK_EX ? "w" : "r";
$this->fh = fopen($storageFile, $mode);
if (!$this->fh) {
$this->client->getLogger()->error(
'Failed to open file during lock acquisition',
array('file' => $storageFile)
);
return false;
}
if ($type == LOCK_EX) {
chmod($storageFile, 0600);
}
$count = 0;
while (!flock($this->fh, $type | LOCK_NB)) {
// Sleep for 10ms.
usleep(10000);
if (++$count < self::MAX_LOCK_RETRIES) {
return false;
}
}
return true;
}
public function unlock($storageFile)
{
if ($this->fh) {
flock($this->fh, LOCK_UN);
}
}
}

184
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/Memcache.php vendored
View File

@ -1,184 +0,0 @@
<?php
/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* A persistent storage class based on the memcache, which is not
* really very persistent, as soon as you restart your memcache daemon
* the storage will be wiped.
*
* Will use either the memcache or memcached extensions, preferring
* memcached.
*
* @author Chris Chabot <chabotc@google.com>
*/
class Google_Cache_Memcache extends Google_Cache_Abstract
{
private $connection = false;
private $mc = false;
private $host;
private $port;
/**
* @var Google_Client the current client
*/
private $client;
public function __construct(Google_Client $client)
{
if (!function_exists('memcache_connect') && !class_exists("Memcached")) {
$error = "Memcache functions not available";
$client->getLogger()->error($error);
throw new Google_Cache_Exception($error);
}
$this->client = $client;
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")) {
$error = "You need to supply a valid memcache host and port";
$client->getLogger()->error($error);
throw new Google_Cache_Exception($error);
}
}
}
/**
* @inheritDoc
*/
public function get($key, $expiration = false)
{
$this->connect();
$ret = false;
if ($this->mc) {
$ret = $this->mc->get($key);
} else {
$ret = memcache_get($this->connection, $key);
}
if ($ret === false) {
$this->client->getLogger()->debug(
'Memcache cache miss',
array('key' => $key)
);
return false;
}
if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
$this->client->getLogger()->debug(
'Memcache cache miss (expired)',
array('key' => $key, 'var' => $ret)
);
$this->delete($key);
return false;
}
$this->client->getLogger()->debug(
'Memcache cache hit',
array('key' => $key, 'var' => $ret)
);
return $ret['data'];
}
/**
* @inheritDoc
* @param string $key
* @param string $value
* @throws Google_Cache_Exception
*/
public function set($key, $value)
{
$this->connect();
// we store it with the cache_time default expiration so objects will at
// least get cleaned eventually.
$data = array('time' => time(), 'data' => $value);
$rc = false;
if ($this->mc) {
$rc = $this->mc->set($key, $data);
} else {
$rc = memcache_set($this->connection, $key, $data, false);
}
if ($rc == false) {
$this->client->getLogger()->error(
'Memcache cache set failed',
array('key' => $key, 'var' => $data)
);
throw new Google_Cache_Exception("Couldn't store data in cache");
}
$this->client->getLogger()->debug(
'Memcache cache set',
array('key' => $key, 'var' => $data)
);
}
/**
* @inheritDoc
* @param String $key
*/
public function delete($key)
{
$this->connect();
if ($this->mc) {
$this->mc->delete($key, 0);
} else {
memcache_delete($this->connection, $key, 0);
}
$this->client->getLogger()->debug(
'Memcache cache delete',
array('key' => $key)
);
}
/**
* Lazy initialiser for memcache connection. Uses pconnect for to take
* advantage of the persistence pool where possible.
*/
private function connect()
{
if ($this->connection) {
return;
}
if (class_exists("Memcached")) {
$this->mc = new Memcached();
$this->mc->addServer($this->host, $this->port);
$this->connection = true;
} else {
$this->connection = memcache_pconnect($this->host, $this->port);
}
if (! $this->connection) {
$error = "Couldn't connect to memcache server";
$this->client->getLogger()->error($error);
throw new Google_Cache_Exception($error);
}
}
}

57
apps/files_external/3rdparty/google-api-php-client/src/Google/Cache/Null.php vendored
View File

@ -1,57 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* A blank storage class, for cases where caching is not
* required.
*/
class Google_Cache_Null extends Google_Cache_Abstract
{
public function __construct(Google_Client $client)
{
}
/**
* @inheritDoc
*/
public function get($key, $expiration = false)
{
return false;
}
/**
* @inheritDoc
*/
public function set($key, $value)
{
// Nop.
}
/**
* @inheritDoc
* @param String $key
*/
public function delete($key)
{
// Nop.
}
}

715
apps/files_external/3rdparty/google-api-php-client/src/Google/Client.php vendored
View File

@ -1,715 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/autoload.php';
}
/**
* The Google API Client
* https://github.com/google/google-api-php-client
*/
class Google_Client
{
const LIBVER = "1.1.5";
const USER_AGENT_SUFFIX = "google-api-php-client/";
/**
* @var Google_Auth_Abstract $auth
*/
private $auth;
/**
* @var Google_IO_Abstract $io
*/
private $io;
/**
* @var Google_Cache_Abstract $cache
*/
private $cache;
/**
* @var Google_Config $config
*/
private $config;
/**
* @var Google_Logger_Abstract $logger
*/
private $logger;
/**
* @var boolean $deferExecution
*/
private $deferExecution = false;
/** @var array $scopes */
// Scopes requested by the client
protected $requestedScopes = array();
// definitions of services that are discovered.
protected $services = array();
// Used to track authenticated state, can't discover services after doing authenticate()
private $authenticated = false;
/**
* Construct the Google Client.
*
* @param $config Google_Config or string for the ini file to load
*/
public function __construct($config = null)
{
if (is_string($config) && strlen($config)) {
$config = new Google_Config($config);
} else if ( !($config instanceof Google_Config)) {
$config = new Google_Config();
if ($this->isAppEngine()) {
// Automatically use Memcache if we're in AppEngine.
$config->setCacheClass('Google_Cache_Memcache');
}
if (version_compare(phpversion(), "5.3.4", "<=") || $this->isAppEngine()) {
// Automatically disable compress.zlib, as currently unsupported.
$config->setClassConfig('Google_Http_Request', 'disable_gzip', true);
}
}
if ($config->getIoClass() == Google_Config::USE_AUTO_IO_SELECTION) {
if (function_exists('curl_version') && function_exists('curl_exec')
&& !$this->isAppEngine()) {
$config->setIoClass("Google_IO_Curl");
} else {
$config->setIoClass("Google_IO_Stream");
}
}
$this->config = $config;
}
/**
* Get a string containing the version of the library.
*
* @return string
*/
public function getLibraryVersion()
{
return self::LIBVER;
}
/**
* Attempt to exchange a code for an valid authentication token.
* If $crossClient is set to true, the request body will not include
* the request_uri argument
* Helper wrapped around the OAuth 2.0 implementation.
*
* @param $code string code from accounts.google.com
* @param $crossClient boolean, whether this is a cross-client authentication
* @return string token
*/
public function authenticate($code, $crossClient = false)
{
$this->authenticated = true;
return $this->getAuth()->authenticate($code, $crossClient);
}
/**
* Loads a service account key and parameters from a JSON
* file from the Google Developer Console. Uses that and the
* given array of scopes to return an assertion credential for
* use with refreshTokenWithAssertionCredential.
*
* @param string $jsonLocation File location of the project-key.json.
* @param array $scopes The scopes to assert.
* @return Google_Auth_AssertionCredentials.
* @
*/
public function loadServiceAccountJson($jsonLocation, $scopes)
{
$data = json_decode(file_get_contents($jsonLocation));
if (isset($data->type) && $data->type == 'service_account') {
// Service Account format.
$cred = new Google_Auth_AssertionCredentials(
$data->client_email,
$scopes,
$data->private_key
);
return $cred;
} else {
throw new Google_Exception("Invalid service account JSON file.");
}
}
/**
* Set the auth config from the JSON string provided.
* This structure should match the file downloaded from
* the "Download JSON" button on in the Google Developer
* Console.
* @param string $json the configuration json
* @throws Google_Exception
*/
public function setAuthConfig($json)
{
$data = json_decode($json);
$key = isset($data->installed) ? 'installed' : 'web';
if (!isset($data->$key)) {
throw new Google_Exception("Invalid client secret JSON file.");
}
$this->setClientId($data->$key->client_id);
$this->setClientSecret($data->$key->client_secret);
if (isset($data->$key->redirect_uris)) {
$this->setRedirectUri($data->$key->redirect_uris[0]);
}
}
/**
* Set the auth config from the JSON file in the path
* provided. This should match the file downloaded from
* the "Download JSON" button on in the Google Developer
* Console.
* @param string $file the file location of the client json
*/
public function setAuthConfigFile($file)
{
$this->setAuthConfig(file_get_contents($file));
}
/**
* @throws Google_Auth_Exception
* @return array
* @visible For Testing
*/
public function prepareScopes()
{
if (empty($this->requestedScopes)) {
throw new Google_Auth_Exception("No scopes specified");
}
$scopes = implode(' ', $this->requestedScopes);
return $scopes;
}
/**
* Set the OAuth 2.0 access token using the string that resulted from calling createAuthUrl()
* or Google_Client#getAccessToken().
* @param string $accessToken JSON encoded string containing in the following format:
* {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",
* "expires_in":3600, "id_token":"TOKEN", "created":1320790426}
*/
public function setAccessToken($accessToken)
{
if ($accessToken == 'null') {
$accessToken = null;
}
$this->getAuth()->setAccessToken($accessToken);
}
/**
* Set the authenticator object
* @param Google_Auth_Abstract $auth
*/
public function setAuth(Google_Auth_Abstract $auth)
{
$this->config->setAuthClass(get_class($auth));
$this->auth = $auth;
}
/**
* Set the IO object
* @param Google_IO_Abstract $io
*/
public function setIo(Google_IO_Abstract $io)
{
$this->config->setIoClass(get_class($io));
$this->io = $io;
}
/**
* Set the Cache object
* @param Google_Cache_Abstract $cache
*/
public function setCache(Google_Cache_Abstract $cache)
{
$this->config->setCacheClass(get_class($cache));
$this->cache = $cache;
}
/**
* Set the Logger object
* @param Google_Logger_Abstract $logger
*/
public function setLogger(Google_Logger_Abstract $logger)
{
$this->config->setLoggerClass(get_class($logger));
$this->logger = $logger;
}
/**
* Construct the OAuth 2.0 authorization request URI.
* @return string
*/
public function createAuthUrl()
{
$scopes = $this->prepareScopes();
return $this->getAuth()->createAuthUrl($scopes);
}
/**
* Get the OAuth 2.0 access token.
* @return string $accessToken JSON encoded string in the following format:
* {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",
* "expires_in":3600,"id_token":"TOKEN", "created":1320790426}
*/
public function getAccessToken()
{
$token = $this->getAuth()->getAccessToken();
// The response is json encoded, so could be the string null.
// It is arguable whether this check should be here or lower
// in the library.
return (null == $token || 'null' == $token || '[]' == $token) ? null : $token;
}
/**
* Get the OAuth 2.0 refresh token.
* @return string $refreshToken refresh token or null if not available
*/
public function getRefreshToken()
{
return $this->getAuth()->getRefreshToken();
}
/**
* Returns if the access_token is expired.
* @return bool Returns True if the access_token is expired.
*/
public function isAccessTokenExpired()
{
return $this->getAuth()->isAccessTokenExpired();
}
/**
* Set OAuth 2.0 "state" parameter to achieve per-request customization.
* @see http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-3.1.2.2
* @param string $state
*/
public function setState($state)
{
$this->getAuth()->setState($state);
}
/**
* @param string $accessType Possible values for access_type include:
* {@code "offline"} to request offline access from the user.
* {@code "online"} to request online access from the user.
*/
public function setAccessType($accessType)
{
$this->config->setAccessType($accessType);
}
/**
* @param string $approvalPrompt Possible values for approval_prompt include:
* {@code "force"} to force the approval UI to appear. (This is the default value)
* {@code "auto"} to request auto-approval when possible.
*/
public function setApprovalPrompt($approvalPrompt)
{
$this->config->setApprovalPrompt($approvalPrompt);
}
/**
* Set the login hint, email address or sub id.
* @param string $loginHint
*/
public function setLoginHint($loginHint)
{
$this->config->setLoginHint($loginHint);
}
/**
* Set the application name, this is included in the User-Agent HTTP header.
* @param string $applicationName
*/
public function setApplicationName($applicationName)
{
$this->config->setApplicationName($applicationName);
}
/**
* Set the OAuth 2.0 Client ID.
* @param string $clientId
*/
public function setClientId($clientId)
{
$this->config->setClientId($clientId);
}
/**
* Set the OAuth 2.0 Client Secret.
* @param string $clientSecret
*/
public function setClientSecret($clientSecret)
{
$this->config->setClientSecret($clientSecret);
}
/**
* Set the OAuth 2.0 Redirect URI.
* @param string $redirectUri
*/
public function setRedirectUri($redirectUri)
{
$this->config->setRedirectUri($redirectUri);
}
/**
* If 'plus.login' is included in the list of requested scopes, you can use
* this method to define types of app activities that your app will write.
* You can find a list of available types here:
* @link https://developers.google.com/+/api/moment-types
*
* @param array $requestVisibleActions Array of app activity types
*/
public function setRequestVisibleActions($requestVisibleActions)
{
if (is_array($requestVisibleActions)) {
$requestVisibleActions = join(" ", $requestVisibleActions);
}
$this->config->setRequestVisibleActions($requestVisibleActions);
}
/**
* Set the developer key to use, these are obtained through the API Console.
* @see http://code.google.com/apis/console-help/#generatingdevkeys
* @param string $developerKey
*/
public function setDeveloperKey($developerKey)
{
$this->config->setDeveloperKey($developerKey);
}
/**
* Set the hd (hosted domain) parameter streamlines the login process for
* Google Apps hosted accounts. By including the domain of the user, you
* restrict sign-in to accounts at that domain.
* @param $hd string - the domain to use.
*/
public function setHostedDomain($hd)
{
$this->config->setHostedDomain($hd);
}
/**
* Set the prompt hint. Valid values are none, consent and select_account.
* If no value is specified and the user has not previously authorized
* access, then the user is shown a consent screen.
* @param $prompt string
*/
public function setPrompt($prompt)
{
$this->config->setPrompt($prompt);
}
/**
* openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
* 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
* an authentication request is valid.
* @param $realm string - the URL-space to use.
*/
public function setOpenidRealm($realm)
{
$this->config->setOpenidRealm($realm);
}
/**
* If this is provided with the value true, and the authorization request is
* granted, the authorization will include any previous authorizations
* granted to this user/application combination for other scopes.
* @param $include boolean - the URL-space to use.
*/
public function setIncludeGrantedScopes($include)
{
$this->config->setIncludeGrantedScopes($include);
}
/**
* Fetches a fresh OAuth 2.0 access token with the given refresh token.
* @param string $refreshToken
*/
public function refreshToken($refreshToken)
{
$this->getAuth()->refreshToken($refreshToken);
}
/**
* Revoke an OAuth2 access token or refresh token. This method will revoke the current access
* token, if a token isn't provided.
* @throws Google_Auth_Exception
* @param string|null $token The token (access token or a refresh token) that should be revoked.
* @return boolean Returns True if the revocation was successful, otherwise False.
*/
public function revokeToken($token = null)
{
return $this->getAuth()->revokeToken($token);
}
/**
* Verify an id_token. This method will verify the current id_token, if one
* isn't provided.
* @throws Google_Auth_Exception
* @param string|null $token The token (id_token) that should be verified.
* @return Google_Auth_LoginTicket Returns an apiLoginTicket if the verification was
* successful.
*/
public function verifyIdToken($token = null)
{
return $this->getAuth()->verifyIdToken($token);
}
/**
* Verify a JWT that was signed with your own certificates.
*
* @param $id_token string The JWT token
* @param $cert_location array of certificates
* @param $audience string the expected consumer of the token
* @param $issuer string the expected issuer, defaults to Google
* @param [$max_expiry] the max lifetime of a token, defaults to MAX_TOKEN_LIFETIME_SECS
* @return mixed token information if valid, false if not
*/
public function verifySignedJwt($id_token, $cert_location, $audience, $issuer, $max_expiry = null)
{
$auth = new Google_Auth_OAuth2($this);
$certs = $auth->retrieveCertsFromLocation($cert_location);
return $auth->verifySignedJwtWithCerts($id_token, $certs, $audience, $issuer, $max_expiry);
}
/**
* @param $creds Google_Auth_AssertionCredentials
*/
public function setAssertionCredentials(Google_Auth_AssertionCredentials $creds)
{
$this->getAuth()->setAssertionCredentials($creds);
}
/**
* Set the scopes to be requested. Must be called before createAuthUrl().
* Will remove any previously configured scopes.
* @param array $scopes, ie: array('https://www.googleapis.com/auth/plus.login',
* 'https://www.googleapis.com/auth/moderator')
*/
public function setScopes($scopes)
{
$this->requestedScopes = array();
$this->addScope($scopes);
}
/**
* This functions adds a scope to be requested as part of the OAuth2.0 flow.
* Will append any scopes not previously requested to the scope parameter.
* A single string will be treated as a scope to request. An array of strings
* will each be appended.
* @param $scope_or_scopes string|array e.g. "profile"
*/
public function addScope($scope_or_scopes)
{
if (is_string($scope_or_scopes) && !in_array($scope_or_scopes, $this->requestedScopes)) {
$this->requestedScopes[] = $scope_or_scopes;
} else if (is_array($scope_or_scopes)) {
foreach ($scope_or_scopes as $scope) {
$this->addScope($scope);
}
}
}
/**
* Returns the list of scopes requested by the client
* @return array the list of scopes
*
*/
public function getScopes()
{
return $this->requestedScopes;
}
/**
* Declare whether batch calls should be used. This may increase throughput
* by making multiple requests in one connection.
*
* @param boolean $useBatch True if the batch support should
* be enabled. Defaults to False.
*/
public function setUseBatch($useBatch)
{
// This is actually an alias for setDefer.
$this->setDefer($useBatch);
}
/**
* Declare whether making API calls should make the call immediately, or
* return a request which can be called with ->execute();
*
* @param boolean $defer True if calls should not be executed right away.
*/
public function setDefer($defer)
{
$this->deferExecution = $defer;
}
/**
* Helper method to execute deferred HTTP requests.
*
* @param $request Google_Http_Request|Google_Http_Batch
* @throws Google_Exception
* @return object of the type of the expected class or array.
*/
public function execute($request)
{
if ($request instanceof Google_Http_Request) {
$request->setUserAgent(
$this->getApplicationName()
. " " . self::USER_AGENT_SUFFIX
. $this->getLibraryVersion()
);
if (!$this->getClassConfig("Google_Http_Request", "disable_gzip")) {
$request->enableGzip();
}
$request->maybeMoveParametersToBody();
return Google_Http_REST::execute($this, $request);
} else if ($request instanceof Google_Http_Batch) {
return $request->execute();
} else {
throw new Google_Exception("Do not know how to execute this type of object.");
}
}
/**
* Whether or not to return raw requests
* @return boolean
*/
public function shouldDefer()
{
return $this->deferExecution;
}
/**
* @return Google_Auth_Abstract Authentication implementation
*/
public function getAuth()
{
if (!isset($this->auth)) {
$class = $this->config->getAuthClass();
$this->auth = new $class($this);
}
return $this->auth;
}
/**
* @return Google_IO_Abstract IO implementation
*/
public function getIo()
{
if (!isset($this->io)) {
$class = $this->config->getIoClass();
$this->io = new $class($this);
}
return $this->io;
}
/**
* @return Google_Cache_Abstract Cache implementation
*/
public function getCache()
{
if (!isset($this->cache)) {
$class = $this->config->getCacheClass();
$this->cache = new $class($this);
}
return $this->cache;
}
/**
* @return Google_Logger_Abstract Logger implementation
*/
public function getLogger()
{
if (!isset($this->logger)) {
$class = $this->config->getLoggerClass();
$this->logger = new $class($this);
}
return $this->logger;
}
/**
* Retrieve custom configuration for a specific class.
* @param $class string|object - class or instance of class to retrieve
* @param $key string optional - key to retrieve
* @return array
*/
public function getClassConfig($class, $key = null)
{
if (!is_string($class)) {
$class = get_class($class);
}
return $this->config->getClassConfig($class, $key);
}
/**
* Set configuration specific to a given class.
* $config->setClassConfig('Google_Cache_File',
* array('directory' => '/tmp/cache'));
* @param $class string|object - The class name for the configuration
* @param $config string key or an array of configuration values
* @param $value string optional - if $config is a key, the value
*
*/
public function setClassConfig($class, $config, $value = null)
{
if (!is_string($class)) {
$class = get_class($class);
}
$this->config->setClassConfig($class, $config, $value);
}
/**
* @return string the base URL to use for calls to the APIs
*/
public function getBasePath()
{
return $this->config->getBasePath();
}
/**
* @return string the name of the application
*/
public function getApplicationName()
{
return $this->config->getApplicationName();
}
/**
* Are we running in Google AppEngine?
* return bool
*/
public function isAppEngine()
{
return (isset($_SERVER['SERVER_SOFTWARE']) &&
strpos($_SERVER['SERVER_SOFTWARE'], 'Google App Engine') !== false);
}
}

101
apps/files_external/3rdparty/google-api-php-client/src/Google/Collection.php vendored
View File

@ -1,101 +0,0 @@
<?php
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/autoload.php';
}
/**
* Extension to the regular Google_Model that automatically
* exposes the items array for iteration, so you can just
* iterate over the object rather than a reference inside.
*/
class Google_Collection extends Google_Model implements Iterator, Countable
{
protected $collection_key = 'items';
public function rewind()
{
if (isset($this->modelData[$this->collection_key])
&& is_array($this->modelData[$this->collection_key])) {
reset($this->modelData[$this->collection_key]);
}
}
public function current()
{
$this->coerceType($this->key());
if (is_array($this->modelData[$this->collection_key])) {
return current($this->modelData[$this->collection_key]);
}
}
public function key()
{
if (isset($this->modelData[$this->collection_key])
&& is_array($this->modelData[$this->collection_key])) {
return key($this->modelData[$this->collection_key]);
}
}
public function next()
{
return next($this->modelData[$this->collection_key]);
}
public function valid()
{
$key = $this->key();
return $key !== null && $key !== false;
}
public function count()
{
if (!isset($this->modelData[$this->collection_key])) {
return 0;
}
return count($this->modelData[$this->collection_key]);
}
public function offsetExists($offset)
{
if (!is_numeric($offset)) {
return parent::offsetExists($offset);
}
return isset($this->modelData[$this->collection_key][$offset]);
}
public function offsetGet($offset)
{
if (!is_numeric($offset)) {
return parent::offsetGet($offset);
}
$this->coerceType($offset);
return $this->modelData[$this->collection_key][$offset];
}
public function offsetSet($offset, $value)
{
if (!is_numeric($offset)) {
return parent::offsetSet($offset, $value);
}
$this->modelData[$this->collection_key][$offset] = $value;
}
public function offsetUnset($offset)
{
if (!is_numeric($offset)) {
return parent::offsetUnset($offset);
}
unset($this->modelData[$this->collection_key][$offset]);
}
private function coerceType($offset)
{
$typeKey = $this->keyType($this->collection_key);
if (isset($this->$typeKey) && !is_object($this->modelData[$this->collection_key][$offset])) {
$type = $this->$typeKey;
$this->modelData[$this->collection_key][$offset] =
new $type($this->modelData[$this->collection_key][$offset]);
}
}
}

456
apps/files_external/3rdparty/google-api-php-client/src/Google/Config.php vendored
View File

@ -1,456 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* A class to contain the library configuration for the Google API client.
*/
class Google_Config
{
const GZIP_DISABLED = true;
const GZIP_ENABLED = false;
const GZIP_UPLOADS_ENABLED = true;
const GZIP_UPLOADS_DISABLED = false;
const USE_AUTO_IO_SELECTION = "auto";
const TASK_RETRY_NEVER = 0;
const TASK_RETRY_ONCE = 1;
const TASK_RETRY_ALWAYS = -1;
protected $configuration;
/**
* Create a new Google_Config. Can accept an ini file location with the
* local configuration. For example:
* application_name="My App"
*
* @param [$ini_file_location] - optional - The location of the ini file to load
*/
public function __construct($ini_file_location = null)
{
$this->configuration = array(
// The application_name is included in the User-Agent HTTP header.
'application_name' => '',
// Which Authentication, Storage and HTTP IO classes to use.
'auth_class' => 'Google_Auth_OAuth2',
'io_class' => self::USE_AUTO_IO_SELECTION,
'cache_class' => 'Google_Cache_File',
'logger_class' => 'Google_Logger_Null',
// Don't change these unless you're working against a special development
// or testing environment.
'base_path' => 'https://www.googleapis.com',
// Definition of class specific values, like file paths and so on.
'classes' => array(
'Google_IO_Abstract' => array(
'request_timeout_seconds' => 100,
),
'Google_IO_Curl' => array(
'disable_proxy_workaround' => false,
'options' => null,
),
'Google_Logger_Abstract' => array(
'level' => 'debug',
'log_format' => "[%datetime%] %level%: %message% %context%\n",
'date_format' => 'd/M/Y:H:i:s O',
'allow_newlines' => true
),
'Google_Logger_File' => array(
'file' => 'php://stdout',
'mode' => 0640,
'lock' => false,
),
'Google_Http_Request' => array(
// Disable the use of gzip on calls if set to true. Defaults to false.
'disable_gzip' => self::GZIP_ENABLED,
// We default gzip to disabled on uploads even if gzip is otherwise
// enabled, due to some issues seen with small packet sizes for uploads.
// Please test with this option before enabling gzip for uploads in
// a production environment.
'enable_gzip_for_uploads' => self::GZIP_UPLOADS_DISABLED,
),
// If you want to pass in OAuth 2.0 settings, they will need to be
// structured like this.
'Google_Auth_OAuth2' => array(
// Keys for OAuth 2.0 access, see the API console at
// https://developers.google.com/console
'client_id' => '',
'client_secret' => '',
'redirect_uri' => '',
// Simple API access key, also from the API console. Ensure you get
// a Server key, and not a Browser key.
'developer_key' => '',
// Other parameters.
'hd' => '',
'prompt' => '',
'openid.realm' => '',
'include_granted_scopes' => '',
'login_hint' => '',
'request_visible_actions' => '',
'access_type' => 'online',
'approval_prompt' => 'auto',
'federated_signon_certs_url' =>
'https://www.googleapis.com/oauth2/v1/certs',
),
'Google_Task_Runner' => array(
// Delays are specified in seconds
'initial_delay' => 1,
'max_delay' => 60,
// Base number for exponential backoff
'factor' => 2,
// A random number between -jitter and jitter will be added to the
// factor on each iteration to allow for better distribution of
// retries.
'jitter' => .5,
// Maximum number of retries allowed
'retries' => 0
),
'Google_Service_Exception' => array(
'retry_map' => array(
'500' => self::TASK_RETRY_ALWAYS,
'503' => self::TASK_RETRY_ALWAYS,
'rateLimitExceeded' => self::TASK_RETRY_ALWAYS,
'userRateLimitExceeded' => self::TASK_RETRY_ALWAYS
)
),
'Google_IO_Exception' => array(
'retry_map' => !extension_loaded('curl') ? array() : array(
CURLE_COULDNT_RESOLVE_HOST => self::TASK_RETRY_ALWAYS,
CURLE_COULDNT_CONNECT => self::TASK_RETRY_ALWAYS,
CURLE_OPERATION_TIMEOUTED => self::TASK_RETRY_ALWAYS,
CURLE_SSL_CONNECT_ERROR => self::TASK_RETRY_ALWAYS,
CURLE_GOT_NOTHING => self::TASK_RETRY_ALWAYS
)
),
// Set a default directory for the file cache.
'Google_Cache_File' => array(
'directory' => sys_get_temp_dir() . '/Google_Client'
)
),
);
if ($ini_file_location) {
$ini = parse_ini_file($ini_file_location, true);
if (is_array($ini) && count($ini)) {
$merged_configuration = $ini + $this->configuration;
if (isset($ini['classes']) && isset($this->configuration['classes'])) {
$merged_configuration['classes'] = $ini['classes'] + $this->configuration['classes'];
}
$this->configuration = $merged_configuration;
}
}
}
/**
* Set configuration specific to a given class.
* $config->setClassConfig('Google_Cache_File',
* array('directory' => '/tmp/cache'));
* @param $class string The class name for the configuration
* @param $config string key or an array of configuration values
* @param $value string optional - if $config is a key, the value
*/
public function setClassConfig($class, $config, $value = null)
{
if (!is_array($config)) {
if (!isset($this->configuration['classes'][$class])) {
$this->configuration['classes'][$class] = array();
}
$this->configuration['classes'][$class][$config] = $value;
} else {
$this->configuration['classes'][$class] = $config;
}
}
public function getClassConfig($class, $key = null)
{
if (!isset($this->configuration['classes'][$class])) {
return null;
}
if ($key === null) {
return $this->configuration['classes'][$class];
} else {
return $this->configuration['classes'][$class][$key];
}
}
/**
* Return the configured cache class.
* @return string
*/
public function getCacheClass()
{
return $this->configuration['cache_class'];
}
/**
* Return the configured logger class.
* @return string
*/
public function getLoggerClass()
{
return $this->configuration['logger_class'];
}
/**
* Return the configured Auth class.
* @return string
*/
public function getAuthClass()
{
return $this->configuration['auth_class'];
}
/**
* Set the auth class.
*
* @param $class string the class name to set
*/
public function setAuthClass($class)
{
$prev = $this->configuration['auth_class'];
if (!isset($this->configuration['classes'][$class]) &&
isset($this->configuration['classes'][$prev])) {
$this->configuration['classes'][$class] =
$this->configuration['classes'][$prev];
}
$this->configuration['auth_class'] = $class;
}
/**
* Set the IO class.
*
* @param $class string the class name to set
*/
public function setIoClass($class)
{
$prev = $this->configuration['io_class'];
if (!isset($this->configuration['classes'][$class]) &&
isset($this->configuration['classes'][$prev])) {
$this->configuration['classes'][$class] =
$this->configuration['classes'][$prev];
}
$this->configuration['io_class'] = $class;
}
/**
* Set the cache class.
*
* @param $class string the class name to set
*/
public function setCacheClass($class)
{
$prev = $this->configuration['cache_class'];
if (!isset($this->configuration['classes'][$class]) &&
isset($this->configuration['classes'][$prev])) {
$this->configuration['classes'][$class] =
$this->configuration['classes'][$prev];
}
$this->configuration['cache_class'] = $class;
}
/**
* Set the logger class.
*
* @param $class string the class name to set
*/
public function setLoggerClass($class)
{
$prev = $this->configuration['logger_class'];
if (!isset($this->configuration['classes'][$class]) &&
isset($this->configuration['classes'][$prev])) {
$this->configuration['classes'][$class] =
$this->configuration['classes'][$prev];
}
$this->configuration['logger_class'] = $class;
}
/**
* Return the configured IO class.
*
* @return string
*/
public function getIoClass()
{
return $this->configuration['io_class'];
}
/**
* Set the application name, this is included in the User-Agent HTTP header.
* @param string $name
*/
public function setApplicationName($name)
{
$this->configuration['application_name'] = $name;
}
/**
* @return string the name of the application
*/
public function getApplicationName()
{
return $this->configuration['application_name'];
}
/**
* Set the client ID for the auth class.
* @param $clientId string - the API console client ID
*/
public function setClientId($clientId)
{
$this->setAuthConfig('client_id', $clientId);
}
/**
* Set the client secret for the auth class.
* @param $secret string - the API console client secret
*/
public function setClientSecret($secret)
{
$this->setAuthConfig('client_secret', $secret);
}
/**
* Set the redirect uri for the auth class. Note that if using the
* Javascript based sign in flow, this should be the string 'postmessage'.
*
* @param $uri string - the URI that users should be redirected to
*/
public function setRedirectUri($uri)
{
$this->setAuthConfig('redirect_uri', $uri);
}
/**
* Set the app activities for the auth class.
* @param $rva string a space separated list of app activity types
*/
public function setRequestVisibleActions($rva)
{
$this->setAuthConfig('request_visible_actions', $rva);
}
/**
* Set the the access type requested (offline or online.)
* @param $access string - the access type
*/
public function setAccessType($access)
{
$this->setAuthConfig('access_type', $access);
}
/**
* Set when to show the approval prompt (auto or force)
* @param $approval string - the approval request
*/
public function setApprovalPrompt($approval)
{
$this->setAuthConfig('approval_prompt', $approval);
}
/**
* Set the login hint (email address or sub identifier)
* @param $hint string
*/
public function setLoginHint($hint)
{
$this->setAuthConfig('login_hint', $hint);
}
/**
* Set the developer key for the auth class. Note that this is separate value
* from the client ID - if it looks like a URL, its a client ID!
* @param $key string - the API console developer key
*/
public function setDeveloperKey($key)
{
$this->setAuthConfig('developer_key', $key);
}
/**
* Set the hd (hosted domain) parameter streamlines the login process for
* Google Apps hosted accounts. By including the domain of the user, you
* restrict sign-in to accounts at that domain.
*
* This should not be used to ensure security on your application - check
* the hd values within an id token (@see Google_Auth_LoginTicket) after sign
* in to ensure that the user is from the domain you were expecting.
*
* @param $hd string - the domain to use.
*/
public function setHostedDomain($hd)
{
$this->setAuthConfig('hd', $hd);
}
/**
* Set the prompt hint. Valid values are none, consent and select_account.
* If no value is specified and the user has not previously authorized
* access, then the user is shown a consent screen.
* @param $prompt string
*/
public function setPrompt($prompt)
{
$this->setAuthConfig('prompt', $prompt);
}
/**
* openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
* 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
* an authentication request is valid.
* @param $realm string - the URL-space to use.
*/
public function setOpenidRealm($realm)
{
$this->setAuthConfig('openid.realm', $realm);
}
/**
* If this is provided with the value true, and the authorization request is
* granted, the authorization will include any previous authorizations
* granted to this user/application combination for other scopes.
* @param $include boolean - the URL-space to use.
*/
public function setIncludeGrantedScopes($include)
{
$this->setAuthConfig(
'include_granted_scopes',
$include ? "true" : "false"
);
}
/**
* @return string the base URL to use for API calls
*/
public function getBasePath()
{
return $this->configuration['base_path'];
}
/**
* Set the auth configuration for the current auth class.
* @param $key - the key to set
* @param $value - the parameter value
*/
private function setAuthConfig($key, $value)
{
if (!isset($this->configuration['classes'][$this->getAuthClass()])) {
$this->configuration['classes'][$this->getAuthClass()] = array();
}
$this->configuration['classes'][$this->getAuthClass()][$key] = $value;
}
}

20
apps/files_external/3rdparty/google-api-php-client/src/Google/Exception.php vendored
View File

@ -1,20 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
class Google_Exception extends Exception
{
}

145
apps/files_external/3rdparty/google-api-php-client/src/Google/Http/Batch.php vendored
View File

@ -1,145 +0,0 @@
<?php
/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Class to handle batched requests to the Google API service.
*/
class Google_Http_Batch
{
/** @var string Multipart Boundary. */
private $boundary;
/** @var array service requests to be executed. */
private $requests = array();
/** @var Google_Client */
private $client;
private $expected_classes = array();
private $root_url;
private $batch_path;
public function __construct(Google_Client $client, $boundary = false, $rootUrl = '', $batchPath = '')
{
$this->client = $client;
$this->root_url = rtrim($rootUrl ? $rootUrl : $this->client->getBasePath(), '/');
$this->batch_path = $batchPath ? $batchPath : 'batch';
$this->expected_classes = array();
$boundary = (false == $boundary) ? mt_rand() : $boundary;
$this->boundary = str_replace('"', '', $boundary);
}
public function add(Google_Http_Request $request, $key = false)
{
if (false == $key) {
$key = mt_rand();
}
$this->requests[$key] = $request;
}
public function execute()
{
$body = '';
/** @var Google_Http_Request $req */
foreach ($this->requests as $key => $req) {
$body .= "--{$this->boundary}\n";
$body .= $req->toBatchString($key) . "\n\n";
$this->expected_classes["response-" . $key] = $req->getExpectedClass();
}
$body .= "--{$this->boundary}--";
$url = $this->root_url . '/' . $this->batch_path;
$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);
}
public function parseResponse(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 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 = Google_Http_REST::decodeHttpResponse($response, $this->client);
$responses[$key] = $response;
} catch (Google_Service_Exception $e) {
// Store the exception as the response, so successful responses
// can be processed.
$responses[$key] = $e;
}
}
}
return $responses;
}
return null;
}
}

185
apps/files_external/3rdparty/google-api-php-client/src/Google/Http/CacheParser.php vendored
View File

@ -1,185 +0,0 @@
<?php
/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Implement the caching directives specified in rfc2616. This
* implementation is guided by the guidance offered in rfc2616-sec13.
*/
class Google_Http_CacheParser
{
public static $CACHEABLE_HTTP_METHODS = array('GET', 'HEAD');
public static $CACHEABLE_STATUS_CODES = array('200', '203', '300', '301');
/**
* Check if an HTTP request can be cached by a private local cache.
*
* @static
* @param Google_Http_Request $resp
* @return bool True if the request is cacheable.
* False if the request is uncacheable.
*/
public static function isRequestCacheable(Google_Http_Request $resp)
{
$method = $resp->getRequestMethod();
if (! in_array($method, self::$CACHEABLE_HTTP_METHODS)) {
return false;
}
// Don't cache authorized requests/responses.
// [rfc2616-14.8] When a shared cache receives a request containing an
// Authorization field, it MUST NOT return the corresponding response
// as a reply to any other request...
if ($resp->getRequestHeader("authorization")) {
return false;
}
return true;
}
/**
* Check if an HTTP response can be cached by a private local cache.
*
* @static
* @param Google_Http_Request $resp
* @return bool True if the response is cacheable.
* False if the response is un-cacheable.
*/
public static function isResponseCacheable(Google_Http_Request $resp)
{
// First, check if the HTTP request was cacheable before inspecting the
// HTTP response.
if (false == self::isRequestCacheable($resp)) {
return false;
}
$code = $resp->getResponseHttpCode();
if (! in_array($code, self::$CACHEABLE_STATUS_CODES)) {
return false;
}
// The resource is uncacheable if the resource is already expired and
// the resource doesn't have an ETag for revalidation.
$etag = $resp->getResponseHeader("etag");
if (self::isExpired($resp) && $etag == false) {
return false;
}
// [rfc2616-14.9.2] If [no-store is] sent in a response, a cache MUST NOT
// store any part of either this response or the request that elicited it.
$cacheControl = $resp->getParsedCacheControl();
if (isset($cacheControl['no-store'])) {
return false;
}
// Pragma: no-cache is an http request directive, but is occasionally
// used as a response header incorrectly.
$pragma = $resp->getResponseHeader('pragma');
if ($pragma == 'no-cache' || strpos($pragma, 'no-cache') !== false) {
return false;
}
// [rfc2616-14.44] Vary: * is extremely difficult to cache. "It implies that
// a cache cannot determine from the request headers of a subsequent request
// whether this response is the appropriate representation."
// Given this, we deem responses with the Vary header as uncacheable.
$vary = $resp->getResponseHeader('vary');
if ($vary) {
return false;
}
return true;
}
/**
* @static
* @param Google_Http_Request $resp
* @return bool True if the HTTP response is considered to be expired.
* False if it is considered to be fresh.
*/
public static function isExpired(Google_Http_Request $resp)
{
// HTTP/1.1 clients and caches MUST treat other invalid date formats,
// especially including the value “0”, as in the past.
$parsedExpires = false;
$responseHeaders = $resp->getResponseHeaders();
if (isset($responseHeaders['expires'])) {
$rawExpires = $responseHeaders['expires'];
// Check for a malformed expires header first.
if (empty($rawExpires) || (is_numeric($rawExpires) && $rawExpires <= 0)) {
return true;
}
// See if we can parse the expires header.
$parsedExpires = strtotime($rawExpires);
if (false == $parsedExpires || $parsedExpires <= 0) {
return true;
}
}
// Calculate the freshness of an http response.
$freshnessLifetime = false;
$cacheControl = $resp->getParsedCacheControl();
if (isset($cacheControl['max-age'])) {
$freshnessLifetime = $cacheControl['max-age'];
}
$rawDate = $resp->getResponseHeader('date');
$parsedDate = strtotime($rawDate);
if (empty($rawDate) || false == $parsedDate) {
// We can't default this to now, as that means future cache reads
// will always pass with the logic below, so we will require a
// date be injected if not supplied.
throw new Google_Exception("All cacheable requests must have creation dates.");
}
if (false == $freshnessLifetime && isset($responseHeaders['expires'])) {
$freshnessLifetime = $parsedExpires - $parsedDate;
}
if (false == $freshnessLifetime) {
return true;
}
// Calculate the age of an http response.
$age = max(0, time() - $parsedDate);
if (isset($responseHeaders['age'])) {
$age = max($age, strtotime($responseHeaders['age']));
}
return $freshnessLifetime <= $age;
}
/**
* Determine if a cache entry should be revalidated with by the origin.
*
* @param Google_Http_Request $response
* @return bool True if the entry is expired, else return false.
*/
public static function mustRevalidate(Google_Http_Request $response)
{
// [13.3] When a cache has a stale entry that it would like to use as a
// response to a client's request, it first has to check with the origin
// server to see if its cached entry is still usable.
return self::isExpired($response);
}
}

341
apps/files_external/3rdparty/google-api-php-client/src/Google/Http/MediaFileUpload.php vendored
View File

@ -1,341 +0,0 @@
<?php
/**
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Manage large file uploads, which may be media but can be any type
* of sizable data.
*/
class Google_Http_MediaFileUpload
{
const UPLOAD_MEDIA_TYPE = 'media';
const UPLOAD_MULTIPART_TYPE = 'multipart';
const UPLOAD_RESUMABLE_TYPE = 'resumable';
/** @var string $mimeType */
private $mimeType;
/** @var string $data */
private $data;
/** @var bool $resumable */
private $resumable;
/** @var int $chunkSize */
private $chunkSize;
/** @var int $size */
private $size;
/** @var string $resumeUri */
private $resumeUri;
/** @var int $progress */
private $progress;
/** @var Google_Client */
private $client;
/** @var Google_Http_Request */
private $request;
/** @var string */
private $boundary;
/**
* Result code from last HTTP call
* @var int
*/
private $httpResultCode;
/**
* @param $mimeType string
* @param $data string The bytes you want to upload.
* @param $resumable bool
* @param bool $chunkSize File will be uploaded in chunks of this many bytes.
* only used if resumable=True
*/
public function __construct(
Google_Client $client,
Google_Http_Request $request,
$mimeType,
$data,
$resumable = false,
$chunkSize = false,
$boundary = false
) {
$this->client = $client;
$this->request = $request;
$this->mimeType = $mimeType;
$this->data = $data;
$this->size = strlen($this->data);
$this->resumable = $resumable;
if (!$chunkSize) {
$chunkSize = 256 * 1024;
}
$this->chunkSize = $chunkSize;
$this->progress = 0;
$this->boundary = $boundary;
// Process Media Request
$this->process();
}
/**
* Set the size of the file that is being uploaded.
* @param $size - int file size in bytes
*/
public function setFileSize($size)
{
$this->size = $size;
}
/**
* Return the progress on the upload
* @return int progress in bytes uploaded.
*/
public function getProgress()
{
return $this->progress;
}
/**
* Return the HTTP result code from the last call made.
* @return int code
*/
public function getHttpResultCode()
{
return $this->httpResultCode;
}
/**
* Sends a PUT-Request to google drive and parses the response,
* setting the appropiate variables from the response()
*
* @param Google_Http_Request $httpRequest the Reuqest which will be send
*
* @return false|mixed false when the upload is unfinished or the decoded http response
*
*/
private function makePutRequest(Google_Http_Request $httpRequest)
{
if ($this->client->getClassConfig("Google_Http_Request", "enable_gzip_for_uploads")) {
$httpRequest->enableGzip();
} else {
$httpRequest->disableGzip();
}
$response = $this->client->getIo()->makeRequest($httpRequest);
$response->setExpectedClass($this->request->getExpectedClass());
$code = $response->getResponseHttpCode();
$this->httpResultCode = $code;
if (308 == $code) {
// Track the amount uploaded.
$range = explode('-', $response->getResponseHeader('range'));
$this->progress = $range[1] + 1;
// Allow for changing upload URLs.
$location = $response->getResponseHeader('location');
if ($location) {
$this->resumeUri = $location;
}
// No problems, but upload not complete.
return false;
} else {
return Google_Http_REST::decodeHttpResponse($response, $this->client);
}
}
/**
* Send the next part of the file to upload.
* @param [$chunk] the next set of bytes to send. If false will used $data passed
* at construct time.
*/
public function nextChunk($chunk = false)
{
if (false == $this->resumeUri) {
$this->resumeUri = $this->fetchResumeUri();
}
if (false == $chunk) {
$chunk = substr($this->data, $this->progress, $this->chunkSize);
}
$lastBytePos = $this->progress + strlen($chunk) - 1;
$headers = array(
'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
'content-type' => $this->request->getRequestHeader('content-type'),
'content-length' => $this->chunkSize,
'expect' => '',
);
$httpRequest = new Google_Http_Request(
$this->resumeUri,
'PUT',
$headers,
$chunk
);
return $this->makePutRequest($httpRequest);
}
/**
* Resume a previously unfinished upload
* @param $resumeUri the resume-URI of the unfinished, resumable upload.
*/
public function resume($resumeUri)
{
$this->resumeUri = $resumeUri;
$headers = array(
'content-range' => "bytes */$this->size",
'content-length' => 0,
);
$httpRequest = new Google_Http_Request(
$this->resumeUri,
'PUT',
$headers
);
return $this->makePutRequest($httpRequest);
}
/**
* @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);
}
}
private function transformToUploadUrl()
{
$base = $this->request->getBaseComponent();
$this->request->setBaseComponent($base . '/upload');
}
/**
* Valid upload types:
* - resumable (UPLOAD_RESUMABLE_TYPE)
* - media (UPLOAD_MEDIA_TYPE)
* - multipart (UPLOAD_MULTIPART_TYPE)
* @param $meta
* @return string
* @visible for testing
*/
public function getUploadType($meta)
{
if ($this->resumable) {
return self::UPLOAD_RESUMABLE_TYPE;
}
if (false == $meta && $this->data) {
return self::UPLOAD_MEDIA_TYPE;
}
return self::UPLOAD_MULTIPART_TYPE;
}
public function getResumeUri()
{
return ( $this->resumeUri !== null ? $this->resumeUri : $this->fetchResumeUri() );
}
private function fetchResumeUri()
{
$result = null;
$body = $this->request->getPostBody();
if ($body) {
$headers = array(
'content-type' => 'application/json; charset=UTF-8',
'content-length' => 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, ';');
}
$error = "Failed to start the resumable upload (HTTP {$message})";
$this->client->getLogger()->error($error);
throw new Google_Exception($error);
}
public function setChunkSize($chunkSize)
{
$this->chunkSize = $chunkSize;
}
}

178
apps/files_external/3rdparty/google-api-php-client/src/Google/Http/REST.php vendored
View File

@ -1,178 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* This class implements the RESTful transport of apiServiceRequest()'s
*/
class Google_Http_REST
{
/**
* Executes a Google_Http_Request and (if applicable) automatically retries
* when errors occur.
*
* @param Google_Client $client
* @param Google_Http_Request $req
* @return array decoded result
* @throws Google_Service_Exception on server side error (ie: not authenticated,
* invalid or malformed post body, invalid url)
*/
public static function execute(Google_Client $client, Google_Http_Request $req)
{
$runner = new Google_Task_Runner(
$client,
sprintf('%s %s', $req->getRequestMethod(), $req->getUrl()),
array(get_class(), 'doExecute'),
array($client, $req)
);
return $runner->run();
}
/**
* Executes a Google_Http_Request
*
* @param Google_Client $client
* @param Google_Http_Request $req
* @return array decoded result
* @throws Google_Service_Exception on server side error (ie: not authenticated,
* invalid or malformed post body, invalid url)
*/
public static function doExecute(Google_Client $client, Google_Http_Request $req)
{
$httpRequest = $client->getIo()->makeRequest($req);
$httpRequest->setExpectedClass($req->getExpectedClass());
return self::decodeHttpResponse($httpRequest, $client);
}
/**
* Decode an HTTP Response.
* @static
* @throws Google_Service_Exception
* @param Google_Http_Request $response The http response to be decoded.
* @param Google_Client $client
* @return mixed|null
*/
public static function decodeHttpResponse($response, Google_Client $client = null)
{
$code = $response->getResponseHttpCode();
$body = $response->getResponseBody();
$decoded = null;
if ((intVal($code)) >= 300) {
$decoded = json_decode($body, true);
$err = 'Error calling ' . $response->getRequestMethod() . ' ' . $response->getUrl();
if (isset($decoded['error']) &&
isset($decoded['error']['message']) &&
isset($decoded['error']['code'])) {
// if we're getting a json encoded error definition, use that instead of the raw response
// body for improved readability
$err .= ": ({$decoded['error']['code']}) {$decoded['error']['message']}";
} else {
$err .= ": ($code) $body";
}
$errors = null;
// Specific check for APIs which don't return error details, such as Blogger.
if (isset($decoded['error']) && isset($decoded['error']['errors'])) {
$errors = $decoded['error']['errors'];
}
$map = null;
if ($client) {
$client->getLogger()->error(
$err,
array('code' => $code, 'errors' => $errors)
);
$map = $client->getClassConfig(
'Google_Service_Exception',
'retry_map'
);
}
throw new Google_Service_Exception($err, $code, null, $errors, $map);
}
// Only attempt to decode the response, if the response code wasn't (204) 'no content'
if ($code != '204') {
if ($response->getExpectedRaw()) {
return $body;
}
$decoded = json_decode($body, true);
if ($decoded === null || $decoded === "") {
$error = "Invalid json in service response: $body";
if ($client) {
$client->getLogger()->error($error);
}
throw new Google_Service_Exception($error);
}
if ($response->getExpectedClass()) {
$class = $response->getExpectedClass();
$decoded = new $class($decoded);
}
}
return $decoded;
}
/**
* Parse/expand request parameters and create a fully qualified
* request uri.
* @static
* @param string $servicePath
* @param string $restPath
* @param array $params
* @return string $requestUrl
*/
public static function createRequestUri($servicePath, $restPath, $params)
{
$requestUrl = $servicePath . $restPath;
$uriTemplateVars = array();
$queryVars = array();
foreach ($params as $paramName => $paramSpec) {
if ($paramSpec['type'] == 'boolean') {
$paramSpec['value'] = ($paramSpec['value']) ? 'true' : 'false';
}
if ($paramSpec['location'] == 'path') {
$uriTemplateVars[$paramName] = $paramSpec['value'];
} else if ($paramSpec['location'] == 'query') {
if (isset($paramSpec['repeated']) && is_array($paramSpec['value'])) {
foreach ($paramSpec['value'] as $value) {
$queryVars[] = $paramName . '=' . rawurlencode(rawurldecode($value));
}
} else {
$queryVars[] = $paramName . '=' . rawurlencode(rawurldecode($paramSpec['value']));
}
}
}
if (count($uriTemplateVars)) {
$uriTemplateParser = new Google_Utils_URITemplate();
$requestUrl = $uriTemplateParser->parse($requestUrl, $uriTemplateVars);
}
if (count($queryVars)) {
$requestUrl .= '?' . implode($queryVars, '&');
}
return $requestUrl;
}
}

504
apps/files_external/3rdparty/google-api-php-client/src/Google/Http/Request.php vendored
View File

@ -1,504 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* HTTP Request to be executed by IO classes. Upon execution, the
* responseHttpCode, responseHeaders and responseBody will be filled in.
*
* @author Chris Chabot <chabotc@google.com>
* @author Chirag Shah <chirags@google.com>
*
*/
class Google_Http_Request
{
const GZIP_UA = " (gzip)";
private $batchHeaders = array(
'Content-Type' => 'application/http',
'Content-Transfer-Encoding' => 'binary',
'MIME-Version' => '1.0',
);
protected $queryParams;
protected $requestMethod;
protected $requestHeaders;
protected $baseComponent = null;
protected $path;
protected $postBody;
protected $userAgent;
protected $canGzip = null;
protected $responseHttpCode;
protected $responseHeaders;
protected $responseBody;
protected $expectedClass;
protected $expectedRaw = false;
public $accessKey;
public function __construct(
$url,
$method = 'GET',
$headers = array(),
$postBody = null
) {
$this->setUrl($url);
$this->setRequestMethod($method);
$this->setRequestHeaders($headers);
$this->setPostBody($postBody);
}
/**
* Misc function that returns the base url component of the $url
* used by the OAuth signing class to calculate the base string
* @return string The base url component of the $url.
*/
public function getBaseComponent()
{
return $this->baseComponent;
}
/**
* Set the base URL that path and query parameters will be added to.
* @param $baseComponent string
*/
public function setBaseComponent($baseComponent)
{
$this->baseComponent = rtrim($baseComponent, '/');
}
/**
* Enable support for gzipped responses with this request.
*/
public function enableGzip()
{
$this->setRequestHeaders(array("Accept-Encoding" => "gzip"));
$this->canGzip = true;
$this->setUserAgent($this->userAgent);
}
/**
* Disable support for gzip responses with this request.
*/
public function disableGzip()
{
if (
isset($this->requestHeaders['accept-encoding']) &&
$this->requestHeaders['accept-encoding'] == "gzip"
) {
unset($this->requestHeaders['accept-encoding']);
}
$this->canGzip = false;
$this->userAgent = str_replace(self::GZIP_UA, "", $this->userAgent);
}
/**
* Can this request accept a gzip response?
* @return bool
*/
public function canGzip()
{
return $this->canGzip;
}
/**
* Misc function that returns an array of the query parameters of the current
* url used by the OAuth signing class to calculate the signature
* @return array Query parameters in the query string.
*/
public function getQueryParams()
{
return $this->queryParams;
}
/**
* Set a new query parameter.
* @param $key - string to set, does not need to be URL encoded
* @param $value - string to set, does not need to be URL encoded
*/
public function setQueryParam($key, $value)
{
$this->queryParams[$key] = $value;
}
/**
* @return string HTTP Response Code.
*/
public function getResponseHttpCode()
{
return (int) $this->responseHttpCode;
}
/**
* @param int $responseHttpCode HTTP Response Code.
*/
public function setResponseHttpCode($responseHttpCode)
{
$this->responseHttpCode = $responseHttpCode;
}
/**
* @return $responseHeaders (array) HTTP Response Headers.
*/
public function getResponseHeaders()
{
return $this->responseHeaders;
}
/**
* @return string HTTP Response Body
*/
public function getResponseBody()
{
return $this->responseBody;
}
/**
* Set the class the response to this request should expect.
*
* @param $class string the class name
*/
public function setExpectedClass($class)
{
$this->expectedClass = $class;
}
/**
* Retrieve the expected class the response should expect.
* @return string class name
*/
public function getExpectedClass()
{
return $this->expectedClass;
}
/**
* Enable expected raw response
*/
public function enableExpectedRaw()
{
$this->expectedRaw = true;
}
/**
* Disable expected raw response
*/
public function disableExpectedRaw()
{
$this->expectedRaw = false;
}
/**
* Expected raw response or not.
* @return boolean expected raw response
*/
public function getExpectedRaw()
{
return $this->expectedRaw;
}
/**
* @param array $headers The HTTP response headers
* to be normalized.
*/
public function setResponseHeaders($headers)
{
$headers = Google_Utils::normalize($headers);
if ($this->responseHeaders) {
$headers = array_merge($this->responseHeaders, $headers);
}
$this->responseHeaders = $headers;
}
/**
* @param string $key
* @return array|boolean Returns the requested HTTP header or
* false if unavailable.
*/
public function getResponseHeader($key)
{
return isset($this->responseHeaders[$key])
? $this->responseHeaders[$key]
: false;
}
/**
* @param string $responseBody The HTTP response body.
*/
public function setResponseBody($responseBody)
{
$this->responseBody = $responseBody;
}
/**
* @return string $url The request URL.
*/
public function getUrl()
{
return $this->baseComponent . $this->path .
(count($this->queryParams) ?
"?" . $this->buildQuery($this->queryParams) :
'');
}
/**
* @return string $method HTTP Request Method.
*/
public function getRequestMethod()
{
return $this->requestMethod;
}
/**
* @return array $headers HTTP Request Headers.
*/
public function getRequestHeaders()
{
return $this->requestHeaders;
}
/**
* @param string $key
* @return array|boolean Returns the requested HTTP header or
* false if unavailable.
*/
public function getRequestHeader($key)
{
return isset($this->requestHeaders[$key])
? $this->requestHeaders[$key]
: false;
}
/**
* @return string $postBody HTTP Request Body.
*/
public function getPostBody()
{
return $this->postBody;
}
/**
* @param string $url the url to set
*/
public function setUrl($url)
{
if (substr($url, 0, 4) != 'http') {
// Force the path become relative.
if (substr($url, 0, 1) !== '/') {
$url = '/' . $url;
}
}
$parts = parse_url($url);
if (isset($parts['host'])) {
$this->baseComponent = sprintf(
"%s%s%s",
isset($parts['scheme']) ? $parts['scheme'] . "://" : '',
isset($parts['host']) ? $parts['host'] : '',
isset($parts['port']) ? ":" . $parts['port'] : ''
);
}
$this->path = isset($parts['path']) ? $parts['path'] : '';
$this->queryParams = array();
if (isset($parts['query'])) {
$this->queryParams = $this->parseQuery($parts['query']);
}
}
/**
* @param string $method Set he HTTP Method and normalize
* it to upper-case, as required by HTTP.
*
*/
public function setRequestMethod($method)
{
$this->requestMethod = strtoupper($method);
}
/**
* @param array $headers The HTTP request headers
* to be set and normalized.
*/
public function setRequestHeaders($headers)
{
$headers = Google_Utils::normalize($headers);
if ($this->requestHeaders) {
$headers = array_merge($this->requestHeaders, $headers);
}
$this->requestHeaders = $headers;
}
/**
* @param string $postBody the postBody to set
*/
public function setPostBody($postBody)
{
$this->postBody = $postBody;
}
/**
* Set the User-Agent Header.
* @param string $userAgent The User-Agent.
*/
public function setUserAgent($userAgent)
{
$this->userAgent = $userAgent;
if ($this->canGzip) {
$this->userAgent = $userAgent . self::GZIP_UA;
}
}
/**
* @return string The User-Agent.
*/
public function getUserAgent()
{
return $this->userAgent;
}
/**
* Returns a cache key depending on if this was an OAuth signed request
* in which case it will use the non-signed url and access key to make this
* cache key unique per authenticated user, else use the plain request url
* @return string The md5 hash of the request cache key.
*/
public function getCacheKey()
{
$key = $this->getUrl();
if (isset($this->accessKey)) {
$key .= $this->accessKey;
}
if (isset($this->requestHeaders['authorization'])) {
$key .= $this->requestHeaders['authorization'];
}
return md5($key);
}
public function getParsedCacheControl()
{
$parsed = array();
$rawCacheControl = $this->getResponseHeader('cache-control');
if ($rawCacheControl) {
$rawCacheControl = str_replace(', ', '&', $rawCacheControl);
parse_str($rawCacheControl, $parsed);
}
return $parsed;
}
/**
* @param string $id
* @return string A string representation of the HTTP Request.
*/
public function toBatchString($id)
{
$str = '';
$path = parse_url($this->getUrl(), PHP_URL_PATH) . "?" .
http_build_query($this->queryParams);
$str .= $this->getRequestMethod() . ' ' . $path . " HTTP/1.1\n";
foreach ($this->getRequestHeaders() as $key => $val) {
$str .= $key . ': ' . $val . "\n";
}
if ($this->getPostBody()) {
$str .= "\n";
$str .= $this->getPostBody();
}
$headers = '';
foreach ($this->batchHeaders as $key => $val) {
$headers .= $key . ': ' . $val . "\n";
}
$headers .= "Content-ID: $id\n";
$str = $headers . "\n" . $str;
return $str;
}
/**
* Our own version of parse_str that allows for multiple variables
* with the same name.
* @param $string - the query string to parse
*/
private function parseQuery($string)
{
$return = array();
$parts = explode("&", $string);
foreach ($parts as $part) {
list($key, $value) = explode('=', $part, 2);
$value = urldecode($value);
if (isset($return[$key])) {
if (!is_array($return[$key])) {
$return[$key] = array($return[$key]);
}
$return[$key][] = $value;
} else {
$return[$key] = $value;
}
}
return $return;
}
/**
* A version of build query that allows for multiple
* duplicate keys.
* @param $parts array of key value pairs
*/
private function buildQuery($parts)
{
$return = array();
foreach ($parts as $key => $value) {
if (is_array($value)) {
foreach ($value as $v) {
$return[] = urlencode($key) . "=" . urlencode($v);
}
} else {
$return[] = urlencode($key) . "=" . urlencode($value);
}
}
return implode('&', $return);
}
/**
* If we're POSTing and have no body to send, we can send the query
* parameters in there, which avoids length issues with longer query
* params.
*/
public function maybeMoveParametersToBody()
{
if ($this->getRequestMethod() == "POST" && empty($this->postBody)) {
$this->setRequestHeaders(
array(
"content-type" =>
"application/x-www-form-urlencoded; charset=UTF-8"
)
);
$this->setPostBody($this->buildQuery($this->queryParams));
$this->queryParams = array();
}
}
}

339
apps/files_external/3rdparty/google-api-php-client/src/Google/IO/Abstract.php vendored
View File

@ -1,339 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Abstract IO base class
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
abstract class Google_IO_Abstract
{
const UNKNOWN_CODE = 0;
const FORM_URLENCODED = 'application/x-www-form-urlencoded';
private static $CONNECTION_ESTABLISHED_HEADERS = array(
"HTTP/1.0 200 Connection established\r\n\r\n",
"HTTP/1.1 200 Connection established\r\n\r\n",
);
private static $ENTITY_HTTP_METHODS = array("POST" => null, "PUT" => null);
private static $HOP_BY_HOP = array(
'connection' => true,
'keep-alive' => true,
'proxy-authenticate' => true,
'proxy-authorization' => true,
'te' => true,
'trailers' => true,
'transfer-encoding' => true,
'upgrade' => true
);
/** @var Google_Client */
protected $client;
public function __construct(Google_Client $client)
{
$this->client = $client;
$timeout = $client->getClassConfig('Google_IO_Abstract', 'request_timeout_seconds');
if ($timeout > 0) {
$this->setTimeout($timeout);
}
}
/**
* Executes a Google_Http_Request
* @param Google_Http_Request $request the http request to be executed
* @return array containing response headers, body, and http code
* @throws Google_IO_Exception on curl or IO error
*/
abstract public function executeRequest(Google_Http_Request $request);
/**
* Set options that update the transport implementation's behavior.
* @param $options
*/
abstract public function setOptions($options);
/**
* Set the maximum request time in seconds.
* @param $timeout in seconds
*/
abstract public function setTimeout($timeout);
/**
* Get the maximum request time in seconds.
* @return timeout in seconds
*/
abstract public function getTimeout();
/**
* Test for the presence of a cURL header processing bug
*
* The cURL bug was present in versions prior to 7.30.0 and caused the header
* length to be miscalculated when a "Connection established" header added by
* some proxies was present.
*
* @return boolean
*/
abstract protected function needsQuirk();
/**
* @visible for testing.
* Cache the response to an HTTP request if it is cacheable.
* @param Google_Http_Request $request
* @return bool Returns true if the insertion was successful.
* Otherwise, return false.
*/
public function setCachedRequest(Google_Http_Request $request)
{
// Determine if the request is cacheable.
if (Google_Http_CacheParser::isResponseCacheable($request)) {
$this->client->getCache()->set($request->getCacheKey(), $request);
return true;
}
return false;
}
/**
* Execute an HTTP Request
*
* @param Google_Http_Request $request the http request to be executed
* @return Google_Http_Request http request with the response http code,
* response headers and response body filled in
* @throws Google_IO_Exception on curl or IO error
*/
public function makeRequest(Google_Http_Request $request)
{
// First, check to see if we have a valid cached version.
$cached = $this->getCachedRequest($request);
if ($cached !== false && $cached instanceof Google_Http_Request) {
if (!$this->checkMustRevalidateCachedRequest($cached, $request)) {
return $cached;
}
}
if (array_key_exists($request->getRequestMethod(), self::$ENTITY_HTTP_METHODS)) {
$request = $this->processEntityRequest($request);
}
list($responseData, $responseHeaders, $respHttpCode) = $this->executeRequest($request);
if ($respHttpCode == 304 && $cached) {
// If the server responded NOT_MODIFIED, return the cached request.
$this->updateCachedRequest($cached, $responseHeaders);
return $cached;
}
if (!isset($responseHeaders['Date']) && !isset($responseHeaders['date'])) {
$responseHeaders['date'] = date("r");
}
$request->setResponseHttpCode($respHttpCode);
$request->setResponseHeaders($responseHeaders);
$request->setResponseBody($responseData);
// Store the request in cache (the function checks to see if the request
// can actually be cached)
$this->setCachedRequest($request);
return $request;
}
/**
* @visible for testing.
* @param Google_Http_Request $request
* @return Google_Http_Request|bool Returns the cached object or
* false if the operation was unsuccessful.
*/
public function getCachedRequest(Google_Http_Request $request)
{
if (false === Google_Http_CacheParser::isRequestCacheable($request)) {
return false;
}
return $this->client->getCache()->get($request->getCacheKey());
}
/**
* @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;
}
/**
* Check if an already cached request must be revalidated, and if so update
* the request with the correct ETag headers.
* @param Google_Http_Request $cached A previously cached response.
* @param Google_Http_Request $request The outbound request.
* return bool If the cached object needs to be revalidated, false if it is
* still current and can be re-used.
*/
protected function checkMustRevalidateCachedRequest($cached, $request)
{
if (Google_Http_CacheParser::mustRevalidate($cached)) {
$addHeaders = array();
if ($cached->getResponseHeader('etag')) {
// [13.3.4] If an entity tag has been provided by the origin server,
// we must use that entity tag in any cache-conditional request.
$addHeaders['If-None-Match'] = $cached->getResponseHeader('etag');
} elseif ($cached->getResponseHeader('date')) {
$addHeaders['If-Modified-Since'] = $cached->getResponseHeader('date');
}
$request->setRequestHeaders($addHeaders);
return true;
} else {
return false;
}
}
/**
* Update a cached request, using the headers from the last response.
* @param Google_Http_Request $cached A previously cached response.
* @param mixed Associative array of response headers from the last request.
*/
protected function updateCachedRequest($cached, $responseHeaders)
{
$hopByHop = self::$HOP_BY_HOP;
if (!empty($responseHeaders['connection'])) {
$connectionHeaders = array_map(
'strtolower',
array_filter(
array_map('trim', explode(',', $responseHeaders['connection']))
)
);
$hopByHop += array_fill_keys($connectionHeaders, true);
}
$endToEnd = array_diff_key($responseHeaders, $hopByHop);
$cached->setResponseHeaders($endToEnd);
}
/**
* Used by the IO lib and also the batch processing.
*
* @param $respData
* @param $headerSize
* @return array
*/
public function parseHttpResponse($respData, $headerSize)
{
// check proxy header
foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {
if (stripos($respData, $established_header) !== false) {
// existed, remove it
$respData = str_ireplace($established_header, '', $respData);
// Subtract the proxy header size unless the cURL bug prior to 7.30.0
// is present which prevented the proxy header size from being taken into
// account.
if (!$this->needsQuirk()) {
$headerSize -= strlen($established_header);
}
break;
}
}
if ($headerSize) {
$responseBody = substr($respData, $headerSize);
$responseHeaders = substr($respData, 0, $headerSize);
} else {
$responseSegments = explode("\r\n\r\n", $respData, 2);
$responseHeaders = $responseSegments[0];
$responseBody = isset($responseSegments[1]) ? $responseSegments[1] :
null;
}
$responseHeaders = $this->getHttpResponseHeaders($responseHeaders);
return array($responseHeaders, $responseBody);
}
/**
* Parse out headers from raw headers
* @param rawHeaders array or string
* @return array
*/
public function getHttpResponseHeaders($rawHeaders)
{
if (is_array($rawHeaders)) {
return $this->parseArrayHeaders($rawHeaders);
} else {
return $this->parseStringHeaders($rawHeaders);
}
}
private function parseStringHeaders($rawHeaders)
{
$headers = array();
$responseHeaderLines = explode("\r\n", $rawHeaders);
foreach ($responseHeaderLines as $headerLine) {
if ($headerLine && strpos($headerLine, ':') !== false) {
list($header, $value) = explode(': ', $headerLine, 2);
$header = strtolower($header);
if (isset($headers[$header])) {
$headers[$header] .= "\n" . $value;
} else {
$headers[$header] = $value;
}
}
}
return $headers;
}
private function parseArrayHeaders($rawHeaders)
{
$header_count = count($rawHeaders);
$headers = array();
for ($i = 0; $i < $header_count; $i++) {
$header = $rawHeaders[$i];
// Times will have colons in - so we just want the first match.
$header_parts = explode(': ', $header, 2);
if (count($header_parts) == 2) {
$headers[strtolower($header_parts[0])] = $header_parts[1];
}
}
return $headers;
}
}

194
apps/files_external/3rdparty/google-api-php-client/src/Google/IO/Curl.php vendored
View File

@ -1,194 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Curl based implementation of Google_IO.
*
* @author Stuart Langley <slangley@google.com>
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_IO_Curl extends Google_IO_Abstract
{
// cURL hex representation of version 7.30.0
const NO_QUIRK_VERSION = 0x071E00;
private $options = array();
/** @var bool $disableProxyWorkaround */
private $disableProxyWorkaround;
public function __construct(Google_Client $client)
{
if (!extension_loaded('curl')) {
$error = 'The cURL IO handler requires the cURL extension to be enabled';
$client->getLogger()->critical($error);
throw new Google_IO_Exception($error);
}
parent::__construct($client);
$this->disableProxyWorkaround = $this->client->getClassConfig(
'Google_IO_Curl',
'disable_proxy_workaround'
);
}
/**
* Execute an HTTP Request
*
* @param Google_Http_Request $request the http request to be executed
* @return array containing response headers, body, and http code
* @throws Google_IO_Exception on curl or IO error
*/
public function executeRequest(Google_Http_Request $request)
{
$curl = curl_init();
if ($request->getPostBody()) {
curl_setopt($curl, CURLOPT_POSTFIELDS, $request->getPostBody());
}
$requestHeaders = $request->getRequestHeaders();
if ($requestHeaders && is_array($requestHeaders)) {
$curlHeaders = array();
foreach ($requestHeaders as $k => $v) {
$curlHeaders[] = "$k: $v";
}
curl_setopt($curl, CURLOPT_HTTPHEADER, $curlHeaders);
}
curl_setopt($curl, CURLOPT_URL, $request->getUrl());
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $request->getRequestMethod());
curl_setopt($curl, CURLOPT_USERAGENT, $request->getUserAgent());
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, false);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, true);
// The SSL version will be determined by the underlying library
// @see https://github.com/google/google-api-php-client/pull/644
//curl_setopt($curl, CURLOPT_SSLVERSION, 1);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_HEADER, true);
if ($request->canGzip()) {
curl_setopt($curl, CURLOPT_ENCODING, 'gzip,deflate');
}
$options = $this->client->getClassConfig('Google_IO_Curl', 'options');
if (is_array($options)) {
$this->setOptions($options);
}
foreach ($this->options as $key => $var) {
curl_setopt($curl, $key, $var);
}
if (!isset($this->options[CURLOPT_CAINFO])) {
curl_setopt($curl, CURLOPT_CAINFO, dirname(__FILE__) . '/cacerts.pem');
}
$this->client->getLogger()->debug(
'cURL request',
array(
'url' => $request->getUrl(),
'method' => $request->getRequestMethod(),
'headers' => $requestHeaders,
'body' => $request->getPostBody()
)
);
$response = curl_exec($curl);
if ($response === false) {
$error = curl_error($curl);
$code = curl_errno($curl);
$map = $this->client->getClassConfig('Google_IO_Exception', 'retry_map');
$this->client->getLogger()->error('cURL ' . $error);
throw new Google_IO_Exception($error, $code, null, $map);
}
$headerSize = curl_getinfo($curl, CURLINFO_HEADER_SIZE);
list($responseHeaders, $responseBody) = $this->parseHttpResponse($response, $headerSize);
$responseCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$this->client->getLogger()->debug(
'cURL response',
array(
'code' => $responseCode,
'headers' => $responseHeaders,
'body' => $responseBody,
)
);
return array($responseBody, $responseHeaders, $responseCode);
}
/**
* Set options that update the transport implementation's behavior.
* @param $options
*/
public function setOptions($options)
{
$this->options = $options + $this->options;
}
/**
* Set the maximum request time in seconds.
* @param $timeout in seconds
*/
public function setTimeout($timeout)
{
// Since this timeout is really for putting a bound on the time
// we'll set them both to the same. If you need to specify a longer
// CURLOPT_TIMEOUT, or a higher CONNECTTIMEOUT, the best thing to
// do is use the setOptions method for the values individually.
$this->options[CURLOPT_CONNECTTIMEOUT] = $timeout;
$this->options[CURLOPT_TIMEOUT] = $timeout;
}
/**
* Get the maximum request time in seconds.
* @return timeout in seconds
*/
public function getTimeout()
{
return $this->options[CURLOPT_TIMEOUT];
}
/**
* Test for the presence of a cURL header processing bug
*
* {@inheritDoc}
*
* @return boolean
*/
protected function needsQuirk()
{
if ($this->disableProxyWorkaround) {
return false;
}
$ver = curl_version();
$versionNum = $ver['version_number'];
return $versionNum < Google_IO_Curl::NO_QUIRK_VERSION;
}
}

69
apps/files_external/3rdparty/google-api-php-client/src/Google/IO/Exception.php vendored
View File

@ -1,69 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_IO_Exception extends Google_Exception implements Google_Task_Retryable
{
/**
* @var array $retryMap Map of errors with retry counts.
*/
private $retryMap = array();
/**
* Creates a new IO exception with an optional retry map.
*
* @param string $message
* @param int $code
* @param Exception|null $previous
* @param array|null $retryMap Map of errors with retry counts.
*/
public function __construct(
$message,
$code = 0,
Exception $previous = null,
array $retryMap = null
) {
if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
parent::__construct($message, $code, $previous);
} else {
parent::__construct($message, $code);
}
if (is_array($retryMap)) {
$this->retryMap = $retryMap;
}
}
/**
* Gets the number of times the associated task can be retried.
*
* NOTE: -1 is returned if the task can be retried indefinitely
*
* @return integer
*/
public function allowedRetries()
{
if (isset($this->retryMap[$this->code])) {
return $this->retryMap[$this->code];
}
return 0;
}
}

243
apps/files_external/3rdparty/google-api-php-client/src/Google/IO/Stream.php vendored
View File

@ -1,243 +0,0 @@
<?php
/*
* Copyright 2013 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Http Streams based implementation of Google_IO.
*
* @author Stuart Langley <slangley@google.com>
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_IO_Stream extends Google_IO_Abstract
{
const TIMEOUT = "timeout";
const ZLIB = "compress.zlib://";
private $options = array();
private $trappedErrorNumber;
private $trappedErrorString;
private static $DEFAULT_HTTP_CONTEXT = array(
"follow_location" => 0,
"ignore_errors" => 1,
);
private static $DEFAULT_SSL_CONTEXT = array(
"verify_peer" => true,
);
public function __construct(Google_Client $client)
{
if (!ini_get('allow_url_fopen')) {
$error = 'The stream IO handler requires the allow_url_fopen runtime ' .
'configuration to be enabled';
$client->getLogger()->critical($error);
throw new Google_IO_Exception($error);
}
parent::__construct($client);
}
/**
* Execute an HTTP Request
*
* @param Google_Http_Request $request the http request to be executed
* @return array containing response headers, body, and http code
* @throws Google_IO_Exception on curl or IO error
*/
public function executeRequest(Google_Http_Request $request)
{
$default_options = stream_context_get_options(stream_context_get_default());
$requestHttpContext = array_key_exists('http', $default_options) ?
$default_options['http'] : array();
if ($request->getPostBody()) {
$requestHttpContext["content"] = $request->getPostBody();
}
$requestHeaders = $request->getRequestHeaders();
if ($requestHeaders && is_array($requestHeaders)) {
$headers = "";
foreach ($requestHeaders as $k => $v) {
$headers .= "$k: $v\r\n";
}
$requestHttpContext["header"] = $headers;
}
$requestHttpContext["method"] = $request->getRequestMethod();
$requestHttpContext["user_agent"] = $request->getUserAgent();
$requestSslContext = array_key_exists('ssl', $default_options) ?
$default_options['ssl'] : array();
if (!$this->client->isAppEngine() && !array_key_exists("cafile", $requestSslContext)) {
$requestSslContext["cafile"] = dirname(__FILE__) . '/cacerts.pem';
}
$options = array(
"http" => array_merge(
self::$DEFAULT_HTTP_CONTEXT,
$requestHttpContext
),
"ssl" => array_merge(
self::$DEFAULT_SSL_CONTEXT,
$requestSslContext
)
);
$context = stream_context_create($options);
$url = $request->getUrl();
if ($request->canGzip()) {
$url = self::ZLIB . $url;
}
$this->client->getLogger()->debug(
'Stream request',
array(
'url' => $url,
'method' => $request->getRequestMethod(),
'headers' => $requestHeaders,
'body' => $request->getPostBody()
)
);
// We are trapping any thrown errors in this method only and
// throwing an exception.
$this->trappedErrorNumber = null;
$this->trappedErrorString = null;
// START - error trap.
set_error_handler(array($this, 'trapError'));
$fh = fopen($url, 'r', false, $context);
restore_error_handler();
// END - error trap.
if ($this->trappedErrorNumber) {
$error = sprintf(
"HTTP Error: Unable to connect: '%s'",
$this->trappedErrorString
);
$this->client->getLogger()->error('Stream ' . $error);
throw new Google_IO_Exception($error, $this->trappedErrorNumber);
}
$response_data = false;
$respHttpCode = self::UNKNOWN_CODE;
if ($fh) {
if (isset($this->options[self::TIMEOUT])) {
stream_set_timeout($fh, $this->options[self::TIMEOUT]);
}
$response_data = stream_get_contents($fh);
fclose($fh);
$respHttpCode = $this->getHttpResponseCode($http_response_header);
}
if (false === $response_data) {
$error = sprintf(
"HTTP Error: Unable to connect: '%s'",
$respHttpCode
);
$this->client->getLogger()->error('Stream ' . $error);
throw new Google_IO_Exception($error, $respHttpCode);
}
$responseHeaders = $this->getHttpResponseHeaders($http_response_header);
$this->client->getLogger()->debug(
'Stream response',
array(
'code' => $respHttpCode,
'headers' => $responseHeaders,
'body' => $response_data,
)
);
return array($response_data, $responseHeaders, $respHttpCode);
}
/**
* Set options that update the transport implementation's behavior.
* @param $options
*/
public function setOptions($options)
{
$this->options = $options + $this->options;
}
/**
* Method to handle errors, used for error handling around
* stream connection methods.
*/
public function trapError($errno, $errstr)
{
$this->trappedErrorNumber = $errno;
$this->trappedErrorString = $errstr;
}
/**
* Set the maximum request time in seconds.
* @param $timeout in seconds
*/
public function setTimeout($timeout)
{
$this->options[self::TIMEOUT] = $timeout;
}
/**
* Get the maximum request time in seconds.
* @return timeout in seconds
*/
public function getTimeout()
{
return $this->options[self::TIMEOUT];
}
/**
* Test for the presence of a cURL header processing bug
*
* {@inheritDoc}
*
* @return boolean
*/
protected function needsQuirk()
{
return false;
}
protected function getHttpResponseCode($response_headers)
{
$header_count = count($response_headers);
for ($i = 0; $i < $header_count; $i++) {
$header = $response_headers[$i];
if (strncasecmp("HTTP", $header, strlen("HTTP")) == 0) {
$response = explode(' ', $header);
return $response[1];
}
}
return self::UNKNOWN_CODE;
}
}

2183
apps/files_external/3rdparty/google-api-php-client/src/Google/IO/cacerts.pem vendored
View File

File diff suppressed because it is too large Load Diff

408
apps/files_external/3rdparty/google-api-php-client/src/Google/Logger/Abstract.php vendored
View File

@ -1,408 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Abstract logging class based on the PSR-3 standard.
*
* NOTE: We don't implement `Psr\Log\LoggerInterface` because we need to
* maintain PHP 5.2 support.
*
* @see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
*/
abstract class Google_Logger_Abstract
{
/**
* Default log format
*/
const DEFAULT_LOG_FORMAT = "[%datetime%] %level%: %message% %context%\n";
/**
* Default date format
*
* Example: 16/Nov/2014:03:26:16 -0500
*/
const DEFAULT_DATE_FORMAT = 'd/M/Y:H:i:s O';
/**
* System is unusable
*/
const EMERGENCY = 'emergency';
/**
* Action must be taken immediately
*
* Example: Entire website down, database unavailable, etc. This should
* trigger the SMS alerts and wake you up.
*/
const ALERT = 'alert';
/**
* Critical conditions
*
* Example: Application component unavailable, unexpected exception.
*/
const CRITICAL = 'critical';
/**
* Runtime errors that do not require immediate action but should typically
* be logged and monitored.
*/
const ERROR = 'error';
/**
* Exceptional occurrences that are not errors.
*
* Example: Use of deprecated APIs, poor use of an API, undesirable things
* that are not necessarily wrong.
*/
const WARNING = 'warning';
/**
* Normal but significant events.
*/
const NOTICE = 'notice';
/**
* Interesting events.
*
* Example: User logs in, SQL logs.
*/
const INFO = 'info';
/**
* Detailed debug information.
*/
const DEBUG = 'debug';
/**
* @var array $levels Logging levels
*/
protected static $levels = array(
self::EMERGENCY => 600,
self::ALERT => 550,
self::CRITICAL => 500,
self::ERROR => 400,
self::WARNING => 300,
self::NOTICE => 250,
self::INFO => 200,
self::DEBUG => 100,
);
/**
* @var integer $level The minimum logging level
*/
protected $level = self::DEBUG;
/**
* @var string $logFormat The current log format
*/
protected $logFormat = self::DEFAULT_LOG_FORMAT;
/**
* @var string $dateFormat The current date format
*/
protected $dateFormat = self::DEFAULT_DATE_FORMAT;
/**
* @var boolean $allowNewLines If newlines are allowed
*/
protected $allowNewLines = false;
/**
* @param Google_Client $client The current Google client
*/
public function __construct(Google_Client $client)
{
$this->setLevel(
$client->getClassConfig('Google_Logger_Abstract', 'level')
);
$format = $client->getClassConfig('Google_Logger_Abstract', 'log_format');
$this->logFormat = $format ? $format : self::DEFAULT_LOG_FORMAT;
$format = $client->getClassConfig('Google_Logger_Abstract', 'date_format');
$this->dateFormat = $format ? $format : self::DEFAULT_DATE_FORMAT;
$this->allowNewLines = (bool) $client->getClassConfig(
'Google_Logger_Abstract',
'allow_newlines'
);
}
/**
* Sets the minimum logging level that this logger handles.
*
* @param integer $level
*/
public function setLevel($level)
{
$this->level = $this->normalizeLevel($level);
}
/**
* Checks if the logger should handle messages at the provided level.
*
* @param integer $level
* @return boolean
*/
public function shouldHandle($level)
{
return $this->normalizeLevel($level) >= $this->level;
}
/**
* System is unusable.
*
* @param string $message The log message
* @param array $context The log context
*/
public function emergency($message, array $context = array())
{
$this->log(self::EMERGENCY, $message, $context);
}
/**
* Action must be taken immediately.
*
* Example: Entire website down, database unavailable, etc. This should
* trigger the SMS alerts and wake you up.
*
* @param string $message The log message
* @param array $context The log context
*/
public function alert($message, array $context = array())
{
$this->log(self::ALERT, $message, $context);
}
/**
* Critical conditions.
*
* Example: Application component unavailable, unexpected exception.
*
* @param string $message The log message
* @param array $context The log context
*/
public function critical($message, array $context = array())
{
$this->log(self::CRITICAL, $message, $context);
}
/**
* Runtime errors that do not require immediate action but should typically
* be logged and monitored.
*
* @param string $message The log message
* @param array $context The log context
*/
public function error($message, array $context = array())
{
$this->log(self::ERROR, $message, $context);
}
/**
* Exceptional occurrences that are not errors.
*
* Example: Use of deprecated APIs, poor use of an API, undesirable things
* that are not necessarily wrong.
*
* @param string $message The log message
* @param array $context The log context
*/
public function warning($message, array $context = array())
{
$this->log(self::WARNING, $message, $context);
}
/**
* Normal but significant events.
*
* @param string $message The log message
* @param array $context The log context
*/
public function notice($message, array $context = array())
{
$this->log(self::NOTICE, $message, $context);
}
/**
* Interesting events.
*
* Example: User logs in, SQL logs.
*
* @param string $message The log message
* @param array $context The log context
*/
public function info($message, array $context = array())
{
$this->log(self::INFO, $message, $context);
}
/**
* Detailed debug information.
*
* @param string $message The log message
* @param array $context The log context
*/
public function debug($message, array $context = array())
{
$this->log(self::DEBUG, $message, $context);
}
/**
* Logs with an arbitrary level.
*
* @param mixed $level The log level
* @param string $message The log message
* @param array $context The log context
*/
public function log($level, $message, array $context = array())
{
if (!$this->shouldHandle($level)) {
return false;
}
$levelName = is_int($level) ? array_search($level, self::$levels) : $level;
$message = $this->interpolate(
array(
'message' => $message,
'context' => $context,
'level' => strtoupper($levelName),
'datetime' => new DateTime(),
)
);
$this->write($message);
}
/**
* Interpolates log variables into the defined log format.
*
* @param array $variables The log variables.
* @return string
*/
protected function interpolate(array $variables = array())
{
$template = $this->logFormat;
if (!$variables['context']) {
$template = str_replace('%context%', '', $template);
unset($variables['context']);
} else {
$this->reverseJsonInContext($variables['context']);
}
foreach ($variables as $key => $value) {
if (strpos($template, '%'. $key .'%') !== false) {
$template = str_replace(
'%' . $key . '%',
$this->export($value),
$template
);
}
}
return $template;
}
/**
* Reverses JSON encoded PHP arrays and objects so that they log better.
*
* @param array $context The log context
*/
protected function reverseJsonInContext(array &$context)
{
if (!$context) {
return;
}
foreach ($context as $key => $val) {
if (!$val || !is_string($val) || !($val[0] == '{' || $val[0] == '[')) {
continue;
}
$json = @json_decode($val);
if (is_object($json) || is_array($json)) {
$context[$key] = $json;
}
}
}
/**
* Exports a PHP value for logging to a string.
*
* @param mixed $value The value to
*/
protected function export($value)
{
if (is_string($value)) {
if ($this->allowNewLines) {
return $value;
}
return preg_replace('/[\r\n]+/', ' ', $value);
}
if (is_resource($value)) {
return sprintf(
'resource(%d) of type (%s)',
$value,
get_resource_type($value)
);
}
if ($value instanceof DateTime) {
return $value->format($this->dateFormat);
}
if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
$options = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE;
if ($this->allowNewLines) {
$options |= JSON_PRETTY_PRINT;
}
return @json_encode($value, $options);
}
return str_replace('\\/', '/', @json_encode($value));
}
/**
* Converts a given log level to the integer form.
*
* @param mixed $level The logging level
* @return integer $level The normalized level
* @throws Google_Logger_Exception If $level is invalid
*/
protected function normalizeLevel($level)
{
if (is_int($level) && array_search($level, self::$levels) !== false) {
return $level;
}
if (is_string($level) && isset(self::$levels[$level])) {
return self::$levels[$level];
}
throw new Google_Logger_Exception(
sprintf("Unknown LogLevel: '%s'", $level)
);
}
/**
* Writes a message to the current log implementation.
*
* @param string $message The message
*/
abstract protected function write($message);
}

24
apps/files_external/3rdparty/google-api-php-client/src/Google/Logger/Exception.php vendored
View File

@ -1,24 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_Logger_Exception extends Google_Exception
{
}

158
apps/files_external/3rdparty/google-api-php-client/src/Google/Logger/File.php vendored
View File

@ -1,158 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* File logging class based on the PSR-3 standard.
*
* This logger writes to a PHP stream resource.
*/
class Google_Logger_File extends Google_Logger_Abstract
{
/**
* @var string|resource $file Where logs are written
*/
private $file;
/**
* @var integer $mode The mode to use if the log file needs to be created
*/
private $mode = 0640;
/**
* @var boolean $lock If a lock should be attempted before writing to the log
*/
private $lock = false;
/**
* @var integer $trappedErrorNumber Trapped error number
*/
private $trappedErrorNumber;
/**
* @var string $trappedErrorString Trapped error string
*/
private $trappedErrorString;
/**
* {@inheritdoc}
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$file = $client->getClassConfig('Google_Logger_File', 'file');
if (!is_string($file) && !is_resource($file)) {
throw new Google_Logger_Exception(
'File logger requires a filename or a valid file pointer'
);
}
$mode = $client->getClassConfig('Google_Logger_File', 'mode');
if (!$mode) {
$this->mode = $mode;
}
$this->lock = (bool) $client->getClassConfig('Google_Logger_File', 'lock');
$this->file = $file;
}
/**
* {@inheritdoc}
*/
protected function write($message)
{
if (is_string($this->file)) {
$this->open();
} elseif (!is_resource($this->file)) {
throw new Google_Logger_Exception('File pointer is no longer available');
}
if ($this->lock) {
flock($this->file, LOCK_EX);
}
fwrite($this->file, (string) $message);
if ($this->lock) {
flock($this->file, LOCK_UN);
}
}
/**
* Opens the log for writing.
*
* @return resource
*/
private function open()
{
// Used for trapping `fopen()` errors.
$this->trappedErrorNumber = null;
$this->trappedErrorString = null;
$old = set_error_handler(array($this, 'trapError'));
$needsChmod = !file_exists($this->file);
$fh = fopen($this->file, 'a');
restore_error_handler();
// Handles trapped `fopen()` errors.
if ($this->trappedErrorNumber) {
throw new Google_Logger_Exception(
sprintf(
"Logger Error: '%s'",
$this->trappedErrorString
),
$this->trappedErrorNumber
);
}
if ($needsChmod) {
@chmod($this->file, $this->mode & ~umask());
}
return $this->file = $fh;
}
/**
* Closes the log stream resource.
*/
private function close()
{
if (is_resource($this->file)) {
fclose($this->file);
}
}
/**
* Traps `fopen()` errors.
*
* @param integer $errno The error number
* @param string $errstr The error string
*/
private function trapError($errno, $errstr)
{
$this->trappedErrorNumber = $errno;
$this->trappedErrorString = $errstr;
}
public function __destruct()
{
$this->close();
}
}

43
apps/files_external/3rdparty/google-api-php-client/src/Google/Logger/Null.php vendored
View File

@ -1,43 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Null logger based on the PSR-3 standard.
*
* This logger simply discards all messages.
*/
class Google_Logger_Null extends Google_Logger_Abstract
{
/**
* {@inheritdoc}
*/
public function shouldHandle($level)
{
return false;
}
/**
* {@inheritdoc}
*/
protected function write($message, array $context = array())
{
}
}

93
apps/files_external/3rdparty/google-api-php-client/src/Google/Logger/Psr.php vendored
View File

@ -1,93 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
/**
* Psr logging class based on the PSR-3 standard.
*
* This logger will delegate all logging to a PSR-3 compatible logger specified
* with the `Google_Logger_Psr::setLogger()` method.
*/
class Google_Logger_Psr extends Google_Logger_Abstract
{
/**
* @param Psr\Log\LoggerInterface $logger The PSR-3 logger
*/
private $logger;
/**
* @param Google_Client $client The current Google client
* @param Psr\Log\LoggerInterface $logger PSR-3 logger where logging will be delegated.
*/
public function __construct(Google_Client $client, /*Psr\Log\LoggerInterface*/ $logger = null)
{
parent::__construct($client);
if ($logger) {
$this->setLogger($logger);
}
}
/**
* Sets the PSR-3 logger where logging will be delegated.
*
* NOTE: The `$logger` should technically implement
* `Psr\Log\LoggerInterface`, but we don't explicitly require this so that
* we can be compatible with PHP 5.2.
*
* @param Psr\Log\LoggerInterface $logger The PSR-3 logger
*/
public function setLogger(/*Psr\Log\LoggerInterface*/ $logger)
{
$this->logger = $logger;
}
/**
* {@inheritdoc}
*/
public function shouldHandle($level)
{
return isset($this->logger) && parent::shouldHandle($level);
}
/**
* {@inheritdoc}
*/
public function log($level, $message, array $context = array())
{
if (!$this->shouldHandle($level)) {
return false;
}
if ($context) {
$this->reverseJsonInContext($context);
}
$levelName = is_int($level) ? array_search($level, self::$levels) : $level;
$this->logger->log($levelName, $message, $context);
}
/**
* {@inheritdoc}
*/
protected function write($message, array $context = array())
{
}
}

295
apps/files_external/3rdparty/google-api-php-client/src/Google/Model.php vendored
View File

@ -1,295 +0,0 @@
<?php
/*
* Copyright 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* This class defines attributes, valid values, and usage which is generated
* from a given json schema.
* http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5
*
*/
class Google_Model implements ArrayAccess
{
/**
* If you need to specify a NULL JSON value, use Google_Model::NULL_VALUE
* instead - it will be replaced when converting to JSON with a real null.
*/
const NULL_VALUE = "{}gapi-php-null";
protected $internal_gapi_mappings = array();
protected $modelData = array();
protected $processed = array();
/**
* Polymorphic - accepts a variable number of arguments dependent
* on the type of the model subclass.
*/
final public function __construct()
{
if (func_num_args() == 1 && is_array(func_get_arg(0))) {
// Initialize the model with the array's contents.
$array = func_get_arg(0);
$this->mapTypes($array);
}
$this->gapiInit();
}
/**
* Getter that handles passthrough access to the data array, and lazy object creation.
* @param string $key Property name.
* @return mixed The value if any, or null.
*/
public function __get($key)
{
$keyTypeName = $this->keyType($key);
$keyDataType = $this->dataType($key);
if (isset($this->$keyTypeName) && !isset($this->processed[$key])) {
if (isset($this->modelData[$key])) {
$val = $this->modelData[$key];
} else if (isset($this->$keyDataType) &&
($this->$keyDataType == 'array' || $this->$keyDataType == 'map')) {
$val = array();
} else {
$val = null;
}
if ($this->isAssociativeArray($val)) {
if (isset($this->$keyDataType) && 'map' == $this->$keyDataType) {
foreach ($val as $arrayKey => $arrayItem) {
$this->modelData[$key][$arrayKey] =
$this->createObjectFromName($keyTypeName, $arrayItem);
}
} else {
$this->modelData[$key] = $this->createObjectFromName($keyTypeName, $val);
}
} else if (is_array($val)) {
$arrayObject = array();
foreach ($val as $arrayIndex => $arrayItem) {
$arrayObject[$arrayIndex] =
$this->createObjectFromName($keyTypeName, $arrayItem);
}
$this->modelData[$key] = $arrayObject;
}
$this->processed[$key] = true;
}
return isset($this->modelData[$key]) ? $this->modelData[$key] : null;
}
/**
* Initialize this object's properties from an array.
*
* @param array $array Used to seed this object's properties.
* @return void
*/
protected function mapTypes($array)
{
// Hard initialise simple types, lazy load more complex ones.
foreach ($array as $key => $val) {
if ( !property_exists($this, $this->keyType($key)) &&
property_exists($this, $key)) {
$this->$key = $val;
unset($array[$key]);
} elseif (property_exists($this, $camelKey = Google_Utils::camelCase($key))) {
// This checks if property exists as camelCase, leaving it in array as snake_case
// in case of backwards compatibility issues.
$this->$camelKey = $val;
}
}
$this->modelData = $array;
}
/**
* Blank initialiser to be used in subclasses to do post-construction initialisation - this
* avoids the need for subclasses to have to implement the variadics handling in their
* constructors.
*/
protected function gapiInit()
{
return;
}
/**
* Create a simplified object suitable for straightforward
* conversion to JSON. This is relatively expensive
* due to the usage of reflection, but shouldn't be called
* a whole lot, and is the most straightforward way to filter.
*/
public function toSimpleObject()
{
$object = new stdClass();
// Process all other data.
foreach ($this->modelData as $key => $val) {
$result = $this->getSimpleValue($val);
if ($result !== null) {
$object->$key = $this->nullPlaceholderCheck($result);
}
}
// Process all public properties.
$reflect = new ReflectionObject($this);
$props = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
foreach ($props as $member) {
$name = $member->getName();
$result = $this->getSimpleValue($this->$name);
if ($result !== null) {
$name = $this->getMappedName($name);
$object->$name = $this->nullPlaceholderCheck($result);
}
}
return $object;
}
/**
* Handle different types of values, primarily
* other objects and map and array data types.
*/
private function getSimpleValue($value)
{
if ($value instanceof Google_Model) {
return $value->toSimpleObject();
} else if (is_array($value)) {
$return = array();
foreach ($value as $key => $a_value) {
$a_value = $this->getSimpleValue($a_value);
if ($a_value !== null) {
$key = $this->getMappedName($key);
$return[$key] = $this->nullPlaceholderCheck($a_value);
}
}
return $return;
}
return $value;
}
/**
* Check whether the value is the null placeholder and return true null.
*/
private function nullPlaceholderCheck($value)
{
if ($value === self::NULL_VALUE) {
return null;
}
return $value;
}
/**
* If there is an internal name mapping, use that.
*/
private function getMappedName($key)
{
if (isset($this->internal_gapi_mappings) &&
isset($this->internal_gapi_mappings[$key])) {
$key = $this->internal_gapi_mappings[$key];
}
return $key;
}
/**
* Returns true only if the array is associative.
* @param array $array
* @return bool True if the array is associative.
*/
protected function isAssociativeArray($array)
{
if (!is_array($array)) {
return false;
}
$keys = array_keys($array);
foreach ($keys as $key) {
if (is_string($key)) {
return true;
}
}
return false;
}
/**
* Given a variable name, discover its type.
*
* @param $name
* @param $item
* @return object The object from the item.
*/
private function createObjectFromName($name, $item)
{
$type = $this->$name;
return new $type($item);
}
/**
* Verify if $obj is an array.
* @throws Google_Exception Thrown if $obj isn't an array.
* @param array $obj Items that should be validated.
* @param string $method Method expecting an array as an argument.
*/
public function assertIsArray($obj, $method)
{
if ($obj && !is_array($obj)) {
throw new Google_Exception(
"Incorrect parameter type passed to $method(). Expected an array."
);
}
}
public function offsetExists($offset)
{
return isset($this->$offset) || isset($this->modelData[$offset]);
}
public function offsetGet($offset)
{
return isset($this->$offset) ?
$this->$offset :
$this->__get($offset);
}
public function offsetSet($offset, $value)
{
if (property_exists($this, $offset)) {
$this->$offset = $value;
} else {
$this->modelData[$offset] = $value;
$this->processed[$offset] = true;
}
}
public function offsetUnset($offset)
{
unset($this->modelData[$offset]);
}
protected function keyType($key)
{
return $key . "Type";
}
protected function dataType($key)
{
return $key . "DataType";
}
public function __isset($key)
{
return isset($this->modelData[$key]);
}
public function __unset($key)
{
unset($this->modelData[$key]);
}
}

56
apps/files_external/3rdparty/google-api-php-client/src/Google/Service.php vendored
View File

@ -1,56 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
class Google_Service
{
public $batchPath;
public $rootUrl;
public $version;
public $servicePath;
public $availableScopes;
public $resource;
private $client;
public function __construct(Google_Client $client)
{
$this->client = $client;
}
/**
* Return the associated Google_Client class.
* @return Google_Client
*/
public function getClient()
{
return $this->client;
}
/**
* Create a new HTTP Batch handler for this service
*
* @return Google_Http_Batch
*/
public function createBatch()
{
return new Google_Http_Batch(
$this->client,
false,
$this->rootUrl,
$this->batchPath
);
}
}

6646
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AdExchangeBuyer.php vendored
View File

File diff suppressed because it is too large Load Diff

1713
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AdExchangeSeller.php vendored
View File

File diff suppressed because it is too large Load Diff

3596
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AdSense.php vendored
View File

File diff suppressed because it is too large Load Diff

2166
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AdSenseHost.php vendored
View File

File diff suppressed because it is too large Load Diff

194
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Admin.php vendored
View File

@ -1,194 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Admin (email_migration_v2).
*
* <p>
* Email Migration API lets you migrate emails of users to Google backends.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/admin-sdk/email-migration/v2/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Admin extends Google_Service
{
/** Manage email messages of users on your domain. */
const EMAIL_MIGRATION =
"https://www.googleapis.com/auth/email.migration";
public $mail;
/**
* Constructs the internal representation of the Admin service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'email/v2/users/';
$this->version = 'email_migration_v2';
$this->serviceName = 'admin';
$this->mail = new Google_Service_Admin_Mail_Resource(
$this,
$this->serviceName,
'mail',
array(
'methods' => array(
'insert' => array(
'path' => '{userKey}/mail',
'httpMethod' => 'POST',
'parameters' => array(
'userKey' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "mail" collection of methods.
* Typical usage is:
* <code>
* $adminService = new Google_Service_Admin(...);
* $mail = $adminService->mail;
* </code>
*/
class Google_Service_Admin_Mail_Resource extends Google_Service_Resource
{
/**
* Insert Mail into Google's Gmail backends (mail.insert)
*
* @param string $userKey The email or immutable id of the user
* @param Google_MailItem $postBody
* @param array $optParams Optional parameters.
*/
public function insert($userKey, Google_Service_Admin_MailItem $postBody, $optParams = array())
{
$params = array('userKey' => $userKey, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('insert', array($params));
}
}
class Google_Service_Admin_MailItem extends Google_Collection
{
protected $collection_key = 'labels';
protected $internal_gapi_mappings = array(
);
public $isDeleted;
public $isDraft;
public $isInbox;
public $isSent;
public $isStarred;
public $isTrash;
public $isUnread;
public $kind;
public $labels;
public function setIsDeleted($isDeleted)
{
$this->isDeleted = $isDeleted;
}
public function getIsDeleted()
{
return $this->isDeleted;
}
public function setIsDraft($isDraft)
{
$this->isDraft = $isDraft;
}
public function getIsDraft()
{
return $this->isDraft;
}
public function setIsInbox($isInbox)
{
$this->isInbox = $isInbox;
}
public function getIsInbox()
{
return $this->isInbox;
}
public function setIsSent($isSent)
{
$this->isSent = $isSent;
}
public function getIsSent()
{
return $this->isSent;
}
public function setIsStarred($isStarred)
{
$this->isStarred = $isStarred;
}
public function getIsStarred()
{
return $this->isStarred;
}
public function setIsTrash($isTrash)
{
$this->isTrash = $isTrash;
}
public function getIsTrash()
{
return $this->isTrash;
}
public function setIsUnread($isUnread)
{
$this->isUnread = $isUnread;
}
public function getIsUnread()
{
return $this->isUnread;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setLabels($labels)
{
$this->labels = $labels;
}
public function getLabels()
{
return $this->labels;
}
}

9899
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Analytics.php vendored
View File

File diff suppressed because it is too large Load Diff

3109
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AndroidEnterprise.php vendored
View File

File diff suppressed because it is too large Load Diff

3842
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AndroidPublisher.php vendored
View File

File diff suppressed because it is too large Load Diff

369
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/AppState.php vendored
View File

@ -1,369 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for AppState (v1).
*
* <p>
* The Google App State API.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/games/services/web/api/states" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_AppState extends Google_Service
{
/** View and manage your data for this application. */
const APPSTATE =
"https://www.googleapis.com/auth/appstate";
public $states;
/**
* Constructs the internal representation of the AppState service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'appstate/v1/';
$this->version = 'v1';
$this->serviceName = 'appstate';
$this->states = new Google_Service_AppState_States_Resource(
$this,
$this->serviceName,
'states',
array(
'methods' => array(
'clear' => array(
'path' => 'states/{stateKey}/clear',
'httpMethod' => 'POST',
'parameters' => array(
'stateKey' => array(
'location' => 'path',
'type' => 'integer',
'required' => true,
),
'currentDataVersion' => array(
'location' => 'query',
'type' => 'string',
),
),
),'delete' => array(
'path' => 'states/{stateKey}',
'httpMethod' => 'DELETE',
'parameters' => array(
'stateKey' => array(
'location' => 'path',
'type' => 'integer',
'required' => true,
),
),
),'get' => array(
'path' => 'states/{stateKey}',
'httpMethod' => 'GET',
'parameters' => array(
'stateKey' => array(
'location' => 'path',
'type' => 'integer',
'required' => true,
),
),
),'list' => array(
'path' => 'states',
'httpMethod' => 'GET',
'parameters' => array(
'includeData' => array(
'location' => 'query',
'type' => 'boolean',
),
),
),'update' => array(
'path' => 'states/{stateKey}',
'httpMethod' => 'PUT',
'parameters' => array(
'stateKey' => array(
'location' => 'path',
'type' => 'integer',
'required' => true,
),
'currentStateVersion' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "states" collection of methods.
* Typical usage is:
* <code>
* $appstateService = new Google_Service_AppState(...);
* $states = $appstateService->states;
* </code>
*/
class Google_Service_AppState_States_Resource extends Google_Service_Resource
{
/**
* Clears (sets to empty) the data for the passed key if and only if the passed
* version matches the currently stored version. This method results in a
* conflict error on version mismatch. (states.clear)
*
* @param int $stateKey The key for the data to be retrieved.
* @param array $optParams Optional parameters.
*
* @opt_param string currentDataVersion The version of the data to be cleared.
* Version strings are returned by the server.
* @return Google_Service_AppState_WriteResult
*/
public function clear($stateKey, $optParams = array())
{
$params = array('stateKey' => $stateKey);
$params = array_merge($params, $optParams);
return $this->call('clear', array($params), "Google_Service_AppState_WriteResult");
}
/**
* Deletes a key and the data associated with it. The key is removed and no
* longer counts against the key quota. Note that since this method is not safe
* in the face of concurrent modifications, it should only be used for
* development and testing purposes. Invoking this method in shipping code can
* result in data loss and data corruption. (states.delete)
*
* @param int $stateKey The key for the data to be retrieved.
* @param array $optParams Optional parameters.
*/
public function delete($stateKey, $optParams = array())
{
$params = array('stateKey' => $stateKey);
$params = array_merge($params, $optParams);
return $this->call('delete', array($params));
}
/**
* Retrieves the data corresponding to the passed key. If the key does not exist
* on the server, an HTTP 404 will be returned. (states.get)
*
* @param int $stateKey The key for the data to be retrieved.
* @param array $optParams Optional parameters.
* @return Google_Service_AppState_GetResponse
*/
public function get($stateKey, $optParams = array())
{
$params = array('stateKey' => $stateKey);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_AppState_GetResponse");
}
/**
* Lists all the states keys, and optionally the state data. (states.listStates)
*
* @param array $optParams Optional parameters.
*
* @opt_param bool includeData Whether to include the full data in addition to
* the version number
* @return Google_Service_AppState_ListResponse
*/
public function listStates($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_AppState_ListResponse");
}
/**
* Update the data associated with the input key if and only if the passed
* version matches the currently stored version. This method is safe in the face
* of concurrent writes. Maximum per-key size is 128KB. (states.update)
*
* @param int $stateKey The key for the data to be retrieved.
* @param Google_UpdateRequest $postBody
* @param array $optParams Optional parameters.
*
* @opt_param string currentStateVersion The version of the app state your
* application is attempting to update. If this does not match the current
* version, this method will return a conflict error. If there is no data stored
* on the server for this key, the update will succeed irrespective of the value
* of this parameter.
* @return Google_Service_AppState_WriteResult
*/
public function update($stateKey, Google_Service_AppState_UpdateRequest $postBody, $optParams = array())
{
$params = array('stateKey' => $stateKey, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_AppState_WriteResult");
}
}
class Google_Service_AppState_GetResponse extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $currentStateVersion;
public $data;
public $kind;
public $stateKey;
public function setCurrentStateVersion($currentStateVersion)
{
$this->currentStateVersion = $currentStateVersion;
}
public function getCurrentStateVersion()
{
return $this->currentStateVersion;
}
public function setData($data)
{
$this->data = $data;
}
public function getData()
{
return $this->data;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setStateKey($stateKey)
{
$this->stateKey = $stateKey;
}
public function getStateKey()
{
return $this->stateKey;
}
}
class Google_Service_AppState_ListResponse extends Google_Collection
{
protected $collection_key = 'items';
protected $internal_gapi_mappings = array(
);
protected $itemsType = 'Google_Service_AppState_GetResponse';
protected $itemsDataType = 'array';
public $kind;
public $maximumKeyCount;
public function setItems($items)
{
$this->items = $items;
}
public function getItems()
{
return $this->items;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setMaximumKeyCount($maximumKeyCount)
{
$this->maximumKeyCount = $maximumKeyCount;
}
public function getMaximumKeyCount()
{
return $this->maximumKeyCount;
}
}
class Google_Service_AppState_UpdateRequest extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $data;
public $kind;
public function setData($data)
{
$this->data = $data;
}
public function getData()
{
return $this->data;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
}
class Google_Service_AppState_WriteResult extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $currentStateVersion;
public $kind;
public $stateKey;
public function setCurrentStateVersion($currentStateVersion)
{
$this->currentStateVersion = $currentStateVersion;
}
public function getCurrentStateVersion()
{
return $this->currentStateVersion;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setStateKey($stateKey)
{
$this->stateKey = $stateKey;
}
public function getStateKey()
{
return $this->stateKey;
}
}

2032
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Appengine.php vendored
View File

File diff suppressed because it is too large Load Diff

570
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Appsactivity.php vendored
View File

@ -1,570 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Appsactivity (v1).
*
* <p>
* Provides a historical view of activity.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/google-apps/activity/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Appsactivity extends Google_Service
{
/** View the activity history of your Google Apps. */
const ACTIVITY =
"https://www.googleapis.com/auth/activity";
/** View and manage the files in your Google Drive. */
const DRIVE =
"https://www.googleapis.com/auth/drive";
/** View and manage metadata of files in your Google Drive. */
const DRIVE_METADATA =
"https://www.googleapis.com/auth/drive.metadata";
/** View metadata for files in your Google Drive. */
const DRIVE_METADATA_READONLY =
"https://www.googleapis.com/auth/drive.metadata.readonly";
/** View the files in your Google Drive. */
const DRIVE_READONLY =
"https://www.googleapis.com/auth/drive.readonly";
public $activities;
/**
* Constructs the internal representation of the Appsactivity service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'appsactivity/v1/';
$this->version = 'v1';
$this->serviceName = 'appsactivity';
$this->activities = new Google_Service_Appsactivity_Activities_Resource(
$this,
$this->serviceName,
'activities',
array(
'methods' => array(
'list' => array(
'path' => 'activities',
'httpMethod' => 'GET',
'parameters' => array(
'drive.ancestorId' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'userId' => array(
'location' => 'query',
'type' => 'string',
),
'groupingStrategy' => array(
'location' => 'query',
'type' => 'string',
),
'drive.fileId' => array(
'location' => 'query',
'type' => 'string',
),
'source' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "activities" collection of methods.
* Typical usage is:
* <code>
* $appsactivityService = new Google_Service_Appsactivity(...);
* $activities = $appsactivityService->activities;
* </code>
*/
class Google_Service_Appsactivity_Activities_Resource extends Google_Service_Resource
{
/**
* Returns a list of activities visible to the current logged in user. Visible
* activities are determined by the visiblity settings of the object that was
* acted on, e.g. Drive files a user can see. An activity is a record of past
* events. Multiple events may be merged if they are similar. A request is
* scoped to activities from a given Google service using the source parameter.
* (activities.listActivities)
*
* @param array $optParams Optional parameters.
*
* @opt_param string drive.ancestorId Identifies the Drive folder containing the
* items for which to return activities.
* @opt_param int pageSize The maximum number of events to return on a page. The
* response includes a continuation token if there are more events.
* @opt_param string pageToken A token to retrieve a specific page of results.
* @opt_param string userId Indicates the user to return activity for. Use the
* special value me to indicate the currently authenticated user.
* @opt_param string groupingStrategy Indicates the strategy to use when
* grouping singleEvents items in the associated combinedEvent object.
* @opt_param string drive.fileId Identifies the Drive item to return activities
* for.
* @opt_param string source The Google service from which to return activities.
* Possible values of source are: - drive.google.com
* @return Google_Service_Appsactivity_ListActivitiesResponse
*/
public function listActivities($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Appsactivity_ListActivitiesResponse");
}
}
class Google_Service_Appsactivity_Activity extends Google_Collection
{
protected $collection_key = 'singleEvents';
protected $internal_gapi_mappings = array(
);
protected $combinedEventType = 'Google_Service_Appsactivity_Event';
protected $combinedEventDataType = '';
protected $singleEventsType = 'Google_Service_Appsactivity_Event';
protected $singleEventsDataType = 'array';
public function setCombinedEvent(Google_Service_Appsactivity_Event $combinedEvent)
{
$this->combinedEvent = $combinedEvent;
}
public function getCombinedEvent()
{
return $this->combinedEvent;
}
public function setSingleEvents($singleEvents)
{
$this->singleEvents = $singleEvents;
}
public function getSingleEvents()
{
return $this->singleEvents;
}
}
class Google_Service_Appsactivity_Event extends Google_Collection
{
protected $collection_key = 'permissionChanges';
protected $internal_gapi_mappings = array(
);
public $additionalEventTypes;
public $eventTimeMillis;
public $fromUserDeletion;
protected $moveType = 'Google_Service_Appsactivity_Move';
protected $moveDataType = '';
protected $permissionChangesType = 'Google_Service_Appsactivity_PermissionChange';
protected $permissionChangesDataType = 'array';
public $primaryEventType;
protected $renameType = 'Google_Service_Appsactivity_Rename';
protected $renameDataType = '';
protected $targetType = 'Google_Service_Appsactivity_Target';
protected $targetDataType = '';
protected $userType = 'Google_Service_Appsactivity_User';
protected $userDataType = '';
public function setAdditionalEventTypes($additionalEventTypes)
{
$this->additionalEventTypes = $additionalEventTypes;
}
public function getAdditionalEventTypes()
{
return $this->additionalEventTypes;
}
public function setEventTimeMillis($eventTimeMillis)
{
$this->eventTimeMillis = $eventTimeMillis;
}
public function getEventTimeMillis()
{
return $this->eventTimeMillis;
}
public function setFromUserDeletion($fromUserDeletion)
{
$this->fromUserDeletion = $fromUserDeletion;
}
public function getFromUserDeletion()
{
return $this->fromUserDeletion;
}
public function setMove(Google_Service_Appsactivity_Move $move)
{
$this->move = $move;
}
public function getMove()
{
return $this->move;
}
public function setPermissionChanges($permissionChanges)
{
$this->permissionChanges = $permissionChanges;
}
public function getPermissionChanges()
{
return $this->permissionChanges;
}
public function setPrimaryEventType($primaryEventType)
{
$this->primaryEventType = $primaryEventType;
}
public function getPrimaryEventType()
{
return $this->primaryEventType;
}
public function setRename(Google_Service_Appsactivity_Rename $rename)
{
$this->rename = $rename;
}
public function getRename()
{
return $this->rename;
}
public function setTarget(Google_Service_Appsactivity_Target $target)
{
$this->target = $target;
}
public function getTarget()
{
return $this->target;
}
public function setUser(Google_Service_Appsactivity_User $user)
{
$this->user = $user;
}
public function getUser()
{
return $this->user;
}
}
class Google_Service_Appsactivity_ListActivitiesResponse extends Google_Collection
{
protected $collection_key = 'activities';
protected $internal_gapi_mappings = array(
);
protected $activitiesType = 'Google_Service_Appsactivity_Activity';
protected $activitiesDataType = 'array';
public $nextPageToken;
public function setActivities($activities)
{
$this->activities = $activities;
}
public function getActivities()
{
return $this->activities;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}
class Google_Service_Appsactivity_Move extends Google_Collection
{
protected $collection_key = 'removedParents';
protected $internal_gapi_mappings = array(
);
protected $addedParentsType = 'Google_Service_Appsactivity_Parent';
protected $addedParentsDataType = 'array';
protected $removedParentsType = 'Google_Service_Appsactivity_Parent';
protected $removedParentsDataType = 'array';
public function setAddedParents($addedParents)
{
$this->addedParents = $addedParents;
}
public function getAddedParents()
{
return $this->addedParents;
}
public function setRemovedParents($removedParents)
{
$this->removedParents = $removedParents;
}
public function getRemovedParents()
{
return $this->removedParents;
}
}
class Google_Service_Appsactivity_Parent extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $id;
public $isRoot;
public $title;
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setIsRoot($isRoot)
{
$this->isRoot = $isRoot;
}
public function getIsRoot()
{
return $this->isRoot;
}
public function setTitle($title)
{
$this->title = $title;
}
public function getTitle()
{
return $this->title;
}
}
class Google_Service_Appsactivity_Permission extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $name;
public $permissionId;
public $role;
public $type;
protected $userType = 'Google_Service_Appsactivity_User';
protected $userDataType = '';
public $withLink;
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setPermissionId($permissionId)
{
$this->permissionId = $permissionId;
}
public function getPermissionId()
{
return $this->permissionId;
}
public function setRole($role)
{
$this->role = $role;
}
public function getRole()
{
return $this->role;
}
public function setType($type)
{
$this->type = $type;
}
public function getType()
{
return $this->type;
}
public function setUser(Google_Service_Appsactivity_User $user)
{
$this->user = $user;
}
public function getUser()
{
return $this->user;
}
public function setWithLink($withLink)
{
$this->withLink = $withLink;
}
public function getWithLink()
{
return $this->withLink;
}
}
class Google_Service_Appsactivity_PermissionChange extends Google_Collection
{
protected $collection_key = 'removedPermissions';
protected $internal_gapi_mappings = array(
);
protected $addedPermissionsType = 'Google_Service_Appsactivity_Permission';
protected $addedPermissionsDataType = 'array';
protected $removedPermissionsType = 'Google_Service_Appsactivity_Permission';
protected $removedPermissionsDataType = 'array';
public function setAddedPermissions($addedPermissions)
{
$this->addedPermissions = $addedPermissions;
}
public function getAddedPermissions()
{
return $this->addedPermissions;
}
public function setRemovedPermissions($removedPermissions)
{
$this->removedPermissions = $removedPermissions;
}
public function getRemovedPermissions()
{
return $this->removedPermissions;
}
}
class Google_Service_Appsactivity_Photo extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $url;
public function setUrl($url)
{
$this->url = $url;
}
public function getUrl()
{
return $this->url;
}
}
class Google_Service_Appsactivity_Rename extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $newTitle;
public $oldTitle;
public function setNewTitle($newTitle)
{
$this->newTitle = $newTitle;
}
public function getNewTitle()
{
return $this->newTitle;
}
public function setOldTitle($oldTitle)
{
$this->oldTitle = $oldTitle;
}
public function getOldTitle()
{
return $this->oldTitle;
}
}
class Google_Service_Appsactivity_Target extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $id;
public $mimeType;
public $name;
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setMimeType($mimeType)
{
$this->mimeType = $mimeType;
}
public function getMimeType()
{
return $this->mimeType;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
}
class Google_Service_Appsactivity_User extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $name;
protected $photoType = 'Google_Service_Appsactivity_Photo';
protected $photoDataType = '';
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setPhoto(Google_Service_Appsactivity_Photo $photo)
{
$this->photo = $photo;
}
public function getPhoto()
{
return $this->photo;
}
}

416
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Audit.php vendored
View File

@ -1,416 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Audit (v1).
*
* <p>
* Lets you access user activities in your enterprise made through various
* applications.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/google-apps/admin-audit/get_started" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Audit extends Google_Service
{
public $activities;
/**
* Constructs the internal representation of the Audit service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->servicePath = 'apps/reporting/audit/v1/';
$this->version = 'v1';
$this->serviceName = 'audit';
$this->activities = new Google_Service_Audit_Activities_Resource(
$this,
$this->serviceName,
'activities',
array(
'methods' => array(
'list' => array(
'path' => '{customerId}/{applicationId}',
'httpMethod' => 'GET',
'parameters' => array(
'customerId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'applicationId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'actorEmail' => array(
'location' => 'query',
'type' => 'string',
),
'actorApplicationId' => array(
'location' => 'query',
'type' => 'string',
),
'actorIpAddress' => array(
'location' => 'query',
'type' => 'string',
),
'caller' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
'eventName' => array(
'location' => 'query',
'type' => 'string',
),
'startTime' => array(
'location' => 'query',
'type' => 'string',
),
'endTime' => array(
'location' => 'query',
'type' => 'string',
),
'continuationToken' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "activities" collection of methods.
* Typical usage is:
* <code>
* $auditService = new Google_Service_Audit(...);
* $activities = $auditService->activities;
* </code>
*/
class Google_Service_Audit_Activities_Resource extends Google_Service_Resource
{
/**
* Retrieves a list of activities for a specific customer and application.
* (activities.listActivities)
*
* @param string $customerId Represents the customer who is the owner of target
* object on which action was performed.
* @param string $applicationId Application ID of the application on which the
* event was performed.
* @param array $optParams Optional parameters.
*
* @opt_param string actorEmail Email address of the user who performed the
* action.
* @opt_param string actorApplicationId Application ID of the application which
* interacted on behalf of the user while performing the event.
* @opt_param string actorIpAddress IP Address of host where the event was
* performed. Supports both IPv4 and IPv6 addresses.
* @opt_param string caller Type of the caller.
* @opt_param int maxResults Number of activity records to be shown in each
* page.
* @opt_param string eventName Name of the event being queried.
* @opt_param string startTime Return events which occured at or after this
* time.
* @opt_param string endTime Return events which occured at or before this time.
* @opt_param string continuationToken Next page URL.
* @return Google_Service_Audit_Activities
*/
public function listActivities($customerId, $applicationId, $optParams = array())
{
$params = array('customerId' => $customerId, 'applicationId' => $applicationId);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Audit_Activities");
}
}
class Google_Service_Audit_Activities extends Google_Collection
{
protected $collection_key = 'items';
protected $internal_gapi_mappings = array(
);
protected $itemsType = 'Google_Service_Audit_Activity';
protected $itemsDataType = 'array';
public $kind;
public $next;
public function setItems($items)
{
$this->items = $items;
}
public function getItems()
{
return $this->items;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNext($next)
{
$this->next = $next;
}
public function getNext()
{
return $this->next;
}
}
class Google_Service_Audit_Activity extends Google_Collection
{
protected $collection_key = 'events';
protected $internal_gapi_mappings = array(
);
protected $actorType = 'Google_Service_Audit_ActivityActor';
protected $actorDataType = '';
protected $eventsType = 'Google_Service_Audit_ActivityEvents';
protected $eventsDataType = 'array';
protected $idType = 'Google_Service_Audit_ActivityId';
protected $idDataType = '';
public $ipAddress;
public $kind;
public $ownerDomain;
public function setActor(Google_Service_Audit_ActivityActor $actor)
{
$this->actor = $actor;
}
public function getActor()
{
return $this->actor;
}
public function setEvents($events)
{
$this->events = $events;
}
public function getEvents()
{
return $this->events;
}
public function setId(Google_Service_Audit_ActivityId $id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setIpAddress($ipAddress)
{
$this->ipAddress = $ipAddress;
}
public function getIpAddress()
{
return $this->ipAddress;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setOwnerDomain($ownerDomain)
{
$this->ownerDomain = $ownerDomain;
}
public function getOwnerDomain()
{
return $this->ownerDomain;
}
}
class Google_Service_Audit_ActivityActor extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $applicationId;
public $callerType;
public $email;
public $key;
public function setApplicationId($applicationId)
{
$this->applicationId = $applicationId;
}
public function getApplicationId()
{
return $this->applicationId;
}
public function setCallerType($callerType)
{
$this->callerType = $callerType;
}
public function getCallerType()
{
return $this->callerType;
}
public function setEmail($email)
{
$this->email = $email;
}
public function getEmail()
{
return $this->email;
}
public function setKey($key)
{
$this->key = $key;
}
public function getKey()
{
return $this->key;
}
}
class Google_Service_Audit_ActivityEvents extends Google_Collection
{
protected $collection_key = 'parameters';
protected $internal_gapi_mappings = array(
);
public $eventType;
public $name;
protected $parametersType = 'Google_Service_Audit_ActivityEventsParameters';
protected $parametersDataType = 'array';
public function setEventType($eventType)
{
$this->eventType = $eventType;
}
public function getEventType()
{
return $this->eventType;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setParameters($parameters)
{
$this->parameters = $parameters;
}
public function getParameters()
{
return $this->parameters;
}
}
class Google_Service_Audit_ActivityEventsParameters extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $name;
public $value;
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
class Google_Service_Audit_ActivityId extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $applicationId;
public $customerId;
public $time;
public $uniqQualifier;
public function setApplicationId($applicationId)
{
$this->applicationId = $applicationId;
}
public function getApplicationId()
{
return $this->applicationId;
}
public function setCustomerId($customerId)
{
$this->customerId = $customerId;
}
public function getCustomerId()
{
return $this->customerId;
}
public function setTime($time)
{
$this->time = $time;
}
public function getTime()
{
return $this->time;
}
public function setUniqQualifier($uniqQualifier)
{
$this->uniqQualifier = $uniqQualifier;
}
public function getUniqQualifier()
{
return $this->uniqQualifier;
}
}

1401
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Autoscaler.php vendored
View File

File diff suppressed because it is too large Load Diff

3607
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Bigquery.php vendored
View File

File diff suppressed because it is too large Load Diff

3330
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Blogger.php vendored
View File

File diff suppressed because it is too large Load Diff

7132
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Books.php vendored
View File

File diff suppressed because it is too large Load Diff

3890
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Calendar.php vendored
View File

File diff suppressed because it is too large Load Diff

1650
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/CivicInfo.php vendored
View File

File diff suppressed because it is too large Load Diff

1533
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Classroom.php vendored
View File

File diff suppressed because it is too large Load Diff

1171
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/CloudMonitoring.php vendored
View File

File diff suppressed because it is too large Load Diff

2285
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/CloudUserAccounts.php vendored
View File

File diff suppressed because it is too large Load Diff

446
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Cloudbilling.php vendored
View File

@ -1,446 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Cloudbilling (v1).
*
* <p>
* Retrieves Google Developers Console billing accounts and associates them with
* projects.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://cloud.google.com/billing/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Cloudbilling extends Google_Service
{
/** View and manage your data across Google Cloud Platform services. */
const CLOUD_PLATFORM =
"https://www.googleapis.com/auth/cloud-platform";
public $billingAccounts;
public $billingAccounts_projects;
public $projects;
/**
* Constructs the internal representation of the Cloudbilling service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://cloudbilling.googleapis.com/';
$this->servicePath = '';
$this->version = 'v1';
$this->serviceName = 'cloudbilling';
$this->billingAccounts = new Google_Service_Cloudbilling_BillingAccounts_Resource(
$this,
$this->serviceName,
'billingAccounts',
array(
'methods' => array(
'get' => array(
'path' => 'v1/{+name}',
'httpMethod' => 'GET',
'parameters' => array(
'name' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1/billingAccounts',
'httpMethod' => 'GET',
'parameters' => array(
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
),
),
)
)
);
$this->billingAccounts_projects = new Google_Service_Cloudbilling_BillingAccountsProjects_Resource(
$this,
$this->serviceName,
'projects',
array(
'methods' => array(
'list' => array(
'path' => 'v1/{+name}/projects',
'httpMethod' => 'GET',
'parameters' => array(
'name' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
),
),
)
)
);
$this->projects = new Google_Service_Cloudbilling_Projects_Resource(
$this,
$this->serviceName,
'projects',
array(
'methods' => array(
'getBillingInfo' => array(
'path' => 'v1/{+name}/billingInfo',
'httpMethod' => 'GET',
'parameters' => array(
'name' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'updateBillingInfo' => array(
'path' => 'v1/{+name}/billingInfo',
'httpMethod' => 'PUT',
'parameters' => array(
'name' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "billingAccounts" collection of methods.
* Typical usage is:
* <code>
* $cloudbillingService = new Google_Service_Cloudbilling(...);
* $billingAccounts = $cloudbillingService->billingAccounts;
* </code>
*/
class Google_Service_Cloudbilling_BillingAccounts_Resource extends Google_Service_Resource
{
/**
* Gets information about a billing account. The current authenticated user must
* be an [owner of the billing
* account](https://support.google.com/cloud/answer/4430947).
* (billingAccounts.get)
*
* @param string $name The resource name of the billing account to retrieve. For
* example, `billingAccounts/012345-567890-ABCDEF`.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudbilling_BillingAccount
*/
public function get($name, $optParams = array())
{
$params = array('name' => $name);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Cloudbilling_BillingAccount");
}
/**
* Lists the billing accounts that the current authenticated user
* [owns](https://support.google.com/cloud/answer/4430947).
* (billingAccounts.listBillingAccounts)
*
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken A token identifying a page of results to return.
* This should be a `next_page_token` value returned from a previous
* `ListBillingAccounts` call. If unspecified, the first page of results is
* returned.
* @opt_param int pageSize Requested page size. The maximum page size is 100;
* this is also the default.
* @return Google_Service_Cloudbilling_ListBillingAccountsResponse
*/
public function listBillingAccounts($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Cloudbilling_ListBillingAccountsResponse");
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $cloudbillingService = new Google_Service_Cloudbilling(...);
* $projects = $cloudbillingService->projects;
* </code>
*/
class Google_Service_Cloudbilling_BillingAccountsProjects_Resource extends Google_Service_Resource
{
/**
* Lists the projects associated with a billing account. The current
* authenticated user must be an [owner of the billing
* account](https://support.google.com/cloud/answer/4430947).
* (projects.listBillingAccountsProjects)
*
* @param string $name The resource name of the billing account associated with
* the projects that you want to list. For example,
* `billingAccounts/012345-567890-ABCDEF`.
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken A token identifying a page of results to be
* returned. This should be a `next_page_token` value returned from a previous
* `ListProjectBillingInfo` call. If unspecified, the first page of results is
* returned.
* @opt_param int pageSize Requested page size. The maximum page size is 100;
* this is also the default.
* @return Google_Service_Cloudbilling_ListProjectBillingInfoResponse
*/
public function listBillingAccountsProjects($name, $optParams = array())
{
$params = array('name' => $name);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Cloudbilling_ListProjectBillingInfoResponse");
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $cloudbillingService = new Google_Service_Cloudbilling(...);
* $projects = $cloudbillingService->projects;
* </code>
*/
class Google_Service_Cloudbilling_Projects_Resource extends Google_Service_Resource
{
/**
* Gets the billing information for a project. The current authenticated user
* must have [permission to view the project](https://cloud.google.com/docs
* /permissions-overview#h.bgs0oxofvnoo ). (projects.getBillingInfo)
*
* @param string $name The resource name of the project for which billing
* information is retrieved. For example, `projects/tokyo-rain-123`.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudbilling_ProjectBillingInfo
*/
public function getBillingInfo($name, $optParams = array())
{
$params = array('name' => $name);
$params = array_merge($params, $optParams);
return $this->call('getBillingInfo', array($params), "Google_Service_Cloudbilling_ProjectBillingInfo");
}
/**
* Sets or updates the billing account associated with a project. You specify
* the new billing account by setting the `billing_account_name` in the
* `ProjectBillingInfo` resource to the resource name of a billing account.
* Associating a project with an open billing account enables billing on the
* project and allows charges for resource usage. If the project already had a
* billing account, this method changes the billing account used for resource
* usage charges. *Note:* Incurred charges that have not yet been reported in
* the transaction history of the Google Developers Console may be billed to the
* new billing account, even if the charge occurred before the new billing
* account was assigned to the project. The current authenticated user must have
* ownership privileges for both the [project](https://cloud.google.com/docs
* /permissions-overview#h.bgs0oxofvnoo ) and the [billing
* account](https://support.google.com/cloud/answer/4430947). You can disable
* billing on the project by setting the `billing_account_name` field to empty.
* This action disassociates the current billing account from the project. Any
* billable activity of your in-use services will stop, and your application
* could stop functioning as expected. Any unbilled charges to date will be
* billed to the previously associated account. The current authenticated user
* must be either an owner of the project or an owner of the billing account for
* the project. Note that associating a project with a *closed* billing account
* will have much the same effect as disabling billing on the project: any paid
* resources used by the project will be shut down. Thus, unless you wish to
* disable billing, you should always call this method with the name of an
* *open* billing account. (projects.updateBillingInfo)
*
* @param string $name The resource name of the project associated with the
* billing information that you want to update. For example, `projects/tokyo-
* rain-123`.
* @param Google_ProjectBillingInfo $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudbilling_ProjectBillingInfo
*/
public function updateBillingInfo($name, Google_Service_Cloudbilling_ProjectBillingInfo $postBody, $optParams = array())
{
$params = array('name' => $name, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('updateBillingInfo', array($params), "Google_Service_Cloudbilling_ProjectBillingInfo");
}
}
class Google_Service_Cloudbilling_BillingAccount extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $displayName;
public $name;
public $open;
public function setDisplayName($displayName)
{
$this->displayName = $displayName;
}
public function getDisplayName()
{
return $this->displayName;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setOpen($open)
{
$this->open = $open;
}
public function getOpen()
{
return $this->open;
}
}
class Google_Service_Cloudbilling_ListBillingAccountsResponse extends Google_Collection
{
protected $collection_key = 'billingAccounts';
protected $internal_gapi_mappings = array(
);
protected $billingAccountsType = 'Google_Service_Cloudbilling_BillingAccount';
protected $billingAccountsDataType = 'array';
public $nextPageToken;
public function setBillingAccounts($billingAccounts)
{
$this->billingAccounts = $billingAccounts;
}
public function getBillingAccounts()
{
return $this->billingAccounts;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}
class Google_Service_Cloudbilling_ListProjectBillingInfoResponse extends Google_Collection
{
protected $collection_key = 'projectBillingInfo';
protected $internal_gapi_mappings = array(
);
public $nextPageToken;
protected $projectBillingInfoType = 'Google_Service_Cloudbilling_ProjectBillingInfo';
protected $projectBillingInfoDataType = 'array';
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
public function setProjectBillingInfo($projectBillingInfo)
{
$this->projectBillingInfo = $projectBillingInfo;
}
public function getProjectBillingInfo()
{
return $this->projectBillingInfo;
}
}
class Google_Service_Cloudbilling_ProjectBillingInfo extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $billingAccountName;
public $billingEnabled;
public $name;
public $projectId;
public function setBillingAccountName($billingAccountName)
{
$this->billingAccountName = $billingAccountName;
}
public function getBillingAccountName()
{
return $this->billingAccountName;
}
public function setBillingEnabled($billingEnabled)
{
$this->billingEnabled = $billingEnabled;
}
public function getBillingEnabled()
{
return $this->billingEnabled;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setProjectId($projectId)
{
$this->projectId = $projectId;
}
public function getProjectId()
{
return $this->projectId;
}
}

1343
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Clouddebugger.php vendored
View File

File diff suppressed because it is too large Load Diff

295
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Cloudlatencytest.php vendored
View File

@ -1,295 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Cloudlatencytest (v2).
*
* <p>
* A Test API to report latency data.</p>
*
* <p>
* For more information about this service, see the API
* <a href="" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Cloudlatencytest extends Google_Service
{
/** View monitoring data for all of your Google Cloud and API projects. */
const MONITORING_READONLY =
"https://www.googleapis.com/auth/monitoring.readonly";
public $statscollection;
/**
* Constructs the internal representation of the Cloudlatencytest service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://cloudlatencytest-pa.googleapis.com/';
$this->servicePath = 'v2/statscollection/';
$this->version = 'v2';
$this->serviceName = 'cloudlatencytest';
$this->statscollection = new Google_Service_Cloudlatencytest_Statscollection_Resource(
$this,
$this->serviceName,
'statscollection',
array(
'methods' => array(
'updateaggregatedstats' => array(
'path' => 'updateaggregatedstats',
'httpMethod' => 'POST',
'parameters' => array(),
),'updatestats' => array(
'path' => 'updatestats',
'httpMethod' => 'POST',
'parameters' => array(),
),
)
)
);
}
}
/**
* The "statscollection" collection of methods.
* Typical usage is:
* <code>
* $cloudlatencytestService = new Google_Service_Cloudlatencytest(...);
* $statscollection = $cloudlatencytestService->statscollection;
* </code>
*/
class Google_Service_Cloudlatencytest_Statscollection_Resource extends Google_Service_Resource
{
/**
* RPC to update the new TCP stats. (statscollection.updateaggregatedstats)
*
* @param Google_AggregatedStats $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudlatencytest_AggregatedStatsReply
*/
public function updateaggregatedstats(Google_Service_Cloudlatencytest_AggregatedStats $postBody, $optParams = array())
{
$params = array('postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('updateaggregatedstats', array($params), "Google_Service_Cloudlatencytest_AggregatedStatsReply");
}
/**
* RPC to update the new TCP stats. (statscollection.updatestats)
*
* @param Google_Stats $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudlatencytest_StatsReply
*/
public function updatestats(Google_Service_Cloudlatencytest_Stats $postBody, $optParams = array())
{
$params = array('postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('updatestats', array($params), "Google_Service_Cloudlatencytest_StatsReply");
}
}
class Google_Service_Cloudlatencytest_AggregatedStats extends Google_Collection
{
protected $collection_key = 'stats';
protected $internal_gapi_mappings = array(
);
protected $statsType = 'Google_Service_Cloudlatencytest_Stats';
protected $statsDataType = 'array';
public function setStats($stats)
{
$this->stats = $stats;
}
public function getStats()
{
return $this->stats;
}
}
class Google_Service_Cloudlatencytest_AggregatedStatsReply extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $testValue;
public function setTestValue($testValue)
{
$this->testValue = $testValue;
}
public function getTestValue()
{
return $this->testValue;
}
}
class Google_Service_Cloudlatencytest_DoubleValue extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $label;
public $value;
public function setLabel($label)
{
$this->label = $label;
}
public function getLabel()
{
return $this->label;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
class Google_Service_Cloudlatencytest_IntValue extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $label;
public $value;
public function setLabel($label)
{
$this->label = $label;
}
public function getLabel()
{
return $this->label;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
class Google_Service_Cloudlatencytest_Stats extends Google_Collection
{
protected $collection_key = 'stringValues';
protected $internal_gapi_mappings = array(
);
protected $doubleValuesType = 'Google_Service_Cloudlatencytest_DoubleValue';
protected $doubleValuesDataType = 'array';
protected $intValuesType = 'Google_Service_Cloudlatencytest_IntValue';
protected $intValuesDataType = 'array';
protected $stringValuesType = 'Google_Service_Cloudlatencytest_StringValue';
protected $stringValuesDataType = 'array';
public $time;
public function setDoubleValues($doubleValues)
{
$this->doubleValues = $doubleValues;
}
public function getDoubleValues()
{
return $this->doubleValues;
}
public function setIntValues($intValues)
{
$this->intValues = $intValues;
}
public function getIntValues()
{
return $this->intValues;
}
public function setStringValues($stringValues)
{
$this->stringValues = $stringValues;
}
public function getStringValues()
{
return $this->stringValues;
}
public function setTime($time)
{
$this->time = $time;
}
public function getTime()
{
return $this->time;
}
}
class Google_Service_Cloudlatencytest_StatsReply extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $testValue;
public function setTestValue($testValue)
{
$this->testValue = $testValue;
}
public function getTestValue()
{
return $this->testValue;
}
}
class Google_Service_Cloudlatencytest_StringValue extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $label;
public $value;
public function setLabel($label)
{
$this->label = $label;
}
public function getLabel()
{
return $this->label;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}

912
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Cloudresourcemanager.php vendored
View File

@ -1,912 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Cloudresourcemanager (v1beta1).
*
* <p>
* The Google Cloud Resource Manager API provides methods for creating, reading,
* and updating of project metadata.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://cloud.google.com/resource-manager" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Cloudresourcemanager extends Google_Service
{
/** View and manage your data across Google Cloud Platform services. */
const CLOUD_PLATFORM =
"https://www.googleapis.com/auth/cloud-platform";
public $organizations;
public $projects;
/**
* Constructs the internal representation of the Cloudresourcemanager service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://cloudresourcemanager.googleapis.com/';
$this->servicePath = '';
$this->version = 'v1beta1';
$this->serviceName = 'cloudresourcemanager';
$this->organizations = new Google_Service_Cloudresourcemanager_Organizations_Resource(
$this,
$this->serviceName,
'organizations',
array(
'methods' => array(
'get' => array(
'path' => 'v1beta1/organizations/{organizationId}',
'httpMethod' => 'GET',
'parameters' => array(
'organizationId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'getIamPolicy' => array(
'path' => 'v1beta1/organizations/{resource}:getIamPolicy',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1beta1/organizations',
'httpMethod' => 'GET',
'parameters' => array(
'filter' => array(
'location' => 'query',
'type' => 'string',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
),
),'setIamPolicy' => array(
'path' => 'v1beta1/organizations/{resource}:setIamPolicy',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'testIamPermissions' => array(
'path' => 'v1beta1/organizations/{resource}:testIamPermissions',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'update' => array(
'path' => 'v1beta1/organizations/{organizationId}',
'httpMethod' => 'PUT',
'parameters' => array(
'organizationId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
$this->projects = new Google_Service_Cloudresourcemanager_Projects_Resource(
$this,
$this->serviceName,
'projects',
array(
'methods' => array(
'create' => array(
'path' => 'v1beta1/projects',
'httpMethod' => 'POST',
'parameters' => array(),
),'delete' => array(
'path' => 'v1beta1/projects/{projectId}',
'httpMethod' => 'DELETE',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'get' => array(
'path' => 'v1beta1/projects/{projectId}',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'getIamPolicy' => array(
'path' => 'v1beta1/projects/{resource}:getIamPolicy',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1beta1/projects',
'httpMethod' => 'GET',
'parameters' => array(
'filter' => array(
'location' => 'query',
'type' => 'string',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
),
),'setIamPolicy' => array(
'path' => 'v1beta1/projects/{resource}:setIamPolicy',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'testIamPermissions' => array(
'path' => 'v1beta1/projects/{resource}:testIamPermissions',
'httpMethod' => 'POST',
'parameters' => array(
'resource' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'undelete' => array(
'path' => 'v1beta1/projects/{projectId}:undelete',
'httpMethod' => 'POST',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'update' => array(
'path' => 'v1beta1/projects/{projectId}',
'httpMethod' => 'PUT',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "organizations" collection of methods.
* Typical usage is:
* <code>
* $cloudresourcemanagerService = new Google_Service_Cloudresourcemanager(...);
* $organizations = $cloudresourcemanagerService->organizations;
* </code>
*/
class Google_Service_Cloudresourcemanager_Organizations_Resource extends Google_Service_Resource
{
/**
* Fetches an Organization resource by id. (organizations.get)
*
* @param string $organizationId The id of the Organization resource to fetch.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Organization
*/
public function get($organizationId, $optParams = array())
{
$params = array('organizationId' => $organizationId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Cloudresourcemanager_Organization");
}
/**
* Gets the access control policy for a Organization resource. May be empty if
* no such policy or resource exists. (organizations.getIamPolicy)
*
* @param string $resource REQUIRED: The resource for which policy is being
* requested. Resource is usually specified as a path, such as,
* `projects/{project}`.
* @param Google_GetIamPolicyRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Policy
*/
public function getIamPolicy($resource, Google_Service_Cloudresourcemanager_GetIamPolicyRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('getIamPolicy', array($params), "Google_Service_Cloudresourcemanager_Policy");
}
/**
* Query Organization resources. (organizations.listOrganizations)
*
* @param array $optParams Optional parameters.
*
* @opt_param string filter An optional query string used to filter the
* Organizations to be return in the response. Filter rules are case-
* insensitive. Organizations may be filtered by `owner.directoryCustomerId` or
* by `domain`, where the domain is a Google for Work domain, for example:
* |Filter|Description| |------|-----------|
* |owner.directorycustomerid:123456789|Organizations with
* `owner.directory_customer_id` equal to `123456789`.|
* |domain:google.com|Organizations corresponding to the domain `google.com`.|
* This field is optional.
* @opt_param string pageToken A pagination token returned from a previous call
* to ListOrganizations that indicates from where listing should continue. This
* field is optional.
* @opt_param int pageSize The maximum number of Organizations to return in the
* response. This field is optional.
* @return Google_Service_Cloudresourcemanager_ListOrganizationsResponse
*/
public function listOrganizations($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Cloudresourcemanager_ListOrganizationsResponse");
}
/**
* Sets the access control policy on a Organization resource. Replaces any
* existing policy. (organizations.setIamPolicy)
*
* @param string $resource REQUIRED: The resource for which policy is being
* specified. `resource` is usually specified as a path, such as,
* `projects/{project}/zones/{zone}/disks/{disk}`.
* @param Google_SetIamPolicyRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Policy
*/
public function setIamPolicy($resource, Google_Service_Cloudresourcemanager_SetIamPolicyRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('setIamPolicy', array($params), "Google_Service_Cloudresourcemanager_Policy");
}
/**
* Returns permissions that a caller has on the specified Organization.
* (organizations.testIamPermissions)
*
* @param string $resource REQUIRED: The resource for which policy detail is
* being requested. `resource` is usually specified as a path, such as,
* `projects/{project}`.
* @param Google_TestIamPermissionsRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_TestIamPermissionsResponse
*/
public function testIamPermissions($resource, Google_Service_Cloudresourcemanager_TestIamPermissionsRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('testIamPermissions', array($params), "Google_Service_Cloudresourcemanager_TestIamPermissionsResponse");
}
/**
* Updates an Organization resource. (organizations.update)
*
* @param string $organizationId An immutable id for the Organization that is
* assigned on creation. This should be omitted when creating a new
* Organization. This field is read-only.
* @param Google_Organization $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Organization
*/
public function update($organizationId, Google_Service_Cloudresourcemanager_Organization $postBody, $optParams = array())
{
$params = array('organizationId' => $organizationId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_Cloudresourcemanager_Organization");
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $cloudresourcemanagerService = new Google_Service_Cloudresourcemanager(...);
* $projects = $cloudresourcemanagerService->projects;
* </code>
*/
class Google_Service_Cloudresourcemanager_Projects_Resource extends Google_Service_Resource
{
/**
* Creates a project resource. Initially, the project resource is owned by its
* creator exclusively. The creator can later grant permission to others to read
* or update the project. Several APIs are activated automatically for the
* project, including Google Cloud Storage. (projects.create)
*
* @param Google_Project $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Project
*/
public function create(Google_Service_Cloudresourcemanager_Project $postBody, $optParams = array())
{
$params = array('postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('create', array($params), "Google_Service_Cloudresourcemanager_Project");
}
/**
* Marks the project identified by the specified `project_id` (for example, `my-
* project-123`) for deletion. This method will only affect the project if the
* following criteria are met: + The project does not have a billing account
* associated with it. + The project has a lifecycle state of
* [ACTIVE][google.cloudresourcemanager.projects.v1beta1.LifecycleState.ACTIVE].
* This method changes the project's lifecycle state from
* [ACTIVE][google.cloudresourcemanager.projects.v1beta1.LifecycleState.ACTIVE]
* to [DELETE_REQUESTED] [google.cloudresourcemanager.projects.v1beta1.Lifecycle
* State.DELETE_REQUESTED]. The deletion starts at an unspecified time, at which
* point the lifecycle state changes to [DELETE_IN_PROGRESS] [google.cloudresour
* cemanager.projects.v1beta1.LifecycleState.DELETE_IN_PROGRESS]. Until the
* deletion completes, you can check the lifecycle state checked by retrieving
* the project with [GetProject]
* [google.cloudresourcemanager.projects.v1beta1.DeveloperProjects.GetProject],
* and the project remains visible to [ListProjects] [google.cloudresourcemanage
* r.projects.v1beta1.DeveloperProjects.ListProjects]. However, you cannot
* update the project. After the deletion completes, the project is not
* retrievable by the [GetProject]
* [google.cloudresourcemanager.projects.v1beta1.DeveloperProjects.GetProject]
* and [ListProjects]
* [google.cloudresourcemanager.projects.v1beta1.DeveloperProjects.ListProjects]
* methods. The caller must have modify permissions for this project.
* (projects.delete)
*
* @param string $projectId The project ID (for example, `foo-bar-123`).
* Required.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Empty
*/
public function delete($projectId, $optParams = array())
{
$params = array('projectId' => $projectId);
$params = array_merge($params, $optParams);
return $this->call('delete', array($params), "Google_Service_Cloudresourcemanager_Empty");
}
/**
* Retrieves the project identified by the specified `project_id` (for example,
* `my-project-123`). The caller must have read permissions for this project.
* (projects.get)
*
* @param string $projectId The project ID (for example, `my-project-123`).
* Required.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Project
*/
public function get($projectId, $optParams = array())
{
$params = array('projectId' => $projectId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Cloudresourcemanager_Project");
}
/**
* Returns the IAM access control policy for specified project.
* (projects.getIamPolicy)
*
* @param string $resource REQUIRED: The resource for which policy is being
* requested. Resource is usually specified as a path, such as,
* `projects/{project}`.
* @param Google_GetIamPolicyRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Policy
*/
public function getIamPolicy($resource, Google_Service_Cloudresourcemanager_GetIamPolicyRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('getIamPolicy', array($params), "Google_Service_Cloudresourcemanager_Policy");
}
/**
* Lists projects that are visible to the user and satisfy the specified filter.
* This method returns projects in an unspecified order. New projects do not
* necessarily appear at the end of the list. (projects.listProjects)
*
* @param array $optParams Optional parameters.
*
* @opt_param string filter An expression for filtering the results of the
* request. Filter rules are case insensitive. The fields eligible for filtering
* are: + `name` + `id` + labels.key where *key* is the name of a label Some
* examples of using labels as filters: |Filter|Description|
* |------|-----------| |name:*|The project has a name.| |name:Howl|The
* project's name is `Howl` or `howl`.| |name:HOWL|Equivalent to above.|
* |NAME:howl|Equivalent to above.| |labels.color:*|The project has the label
* `color`.| |labels.color:red|The project's label `color` has the value `red`.|
* |labels.color:red label.size:big|The project's label `color` has the value
* `red` and its label `size` has the value `big`. Optional.
* @opt_param string pageToken A pagination token returned from a previous call
* to ListProject that indicates from where listing should continue. Note:
* pagination is not yet supported; the server ignores this field. Optional.
* @opt_param int pageSize The maximum number of Projects to return in the
* response. The server can return fewer projects than requested. If
* unspecified, server picks an appropriate default. Note: pagination is not yet
* supported; the server ignores this field. Optional.
* @return Google_Service_Cloudresourcemanager_ListProjectsResponse
*/
public function listProjects($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Cloudresourcemanager_ListProjectsResponse");
}
/**
* Sets the IAM access control policy for the specified project. We do not
* currently support 'domain:' prefixed members in a Binding of a Policy.
* Calling this method requires enabling the App Engine Admin API.
* (projects.setIamPolicy)
*
* @param string $resource REQUIRED: The resource for which policy is being
* specified. `resource` is usually specified as a path, such as,
* `projects/{project}/zones/{zone}/disks/{disk}`.
* @param Google_SetIamPolicyRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Policy
*/
public function setIamPolicy($resource, Google_Service_Cloudresourcemanager_SetIamPolicyRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('setIamPolicy', array($params), "Google_Service_Cloudresourcemanager_Policy");
}
/**
* Tests the specified permissions against the IAM access control policy for the
* specified project. (projects.testIamPermissions)
*
* @param string $resource REQUIRED: The resource for which policy detail is
* being requested. `resource` is usually specified as a path, such as,
* `projects/{project}`.
* @param Google_TestIamPermissionsRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_TestIamPermissionsResponse
*/
public function testIamPermissions($resource, Google_Service_Cloudresourcemanager_TestIamPermissionsRequest $postBody, $optParams = array())
{
$params = array('resource' => $resource, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('testIamPermissions', array($params), "Google_Service_Cloudresourcemanager_TestIamPermissionsResponse");
}
/**
* Restores the project identified by the specified `project_id` (for example,
* `my-project-123`). You can only use this method for a project that has a
* lifecycle state of [DELETE_REQUESTED] [google.cloudresourcemanager.projects.v
* 1beta1.LifecycleState.DELETE_REQUESTED]. After deletion starts, as indicated
* by a lifecycle state of [DELETE_IN_PROGRESS] [google.cloudresourcemanager.pro
* jects.v1beta1.LifecycleState.DELETE_IN_PROGRESS], the project cannot be
* restored. The caller must have modify permissions for this project.
* (projects.undelete)
*
* @param string $projectId The project ID (for example, `foo-bar-123`).
* Required.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Empty
*/
public function undelete($projectId, $optParams = array())
{
$params = array('projectId' => $projectId);
$params = array_merge($params, $optParams);
return $this->call('undelete', array($params), "Google_Service_Cloudresourcemanager_Empty");
}
/**
* Updates the attributes of the project identified by the specified
* `project_id` (for example, `my-project-123`). The caller must have modify
* permissions for this project. (projects.update)
*
* @param string $projectId The project ID (for example, `my-project-123`).
* Required.
* @param Google_Project $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudresourcemanager_Project
*/
public function update($projectId, Google_Service_Cloudresourcemanager_Project $postBody, $optParams = array())
{
$params = array('projectId' => $projectId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_Cloudresourcemanager_Project");
}
}
class Google_Service_Cloudresourcemanager_Binding extends Google_Collection
{
protected $collection_key = 'members';
protected $internal_gapi_mappings = array(
);
public $members;
public $role;
public function setMembers($members)
{
$this->members = $members;
}
public function getMembers()
{
return $this->members;
}
public function setRole($role)
{
$this->role = $role;
}
public function getRole()
{
return $this->role;
}
}
class Google_Service_Cloudresourcemanager_Empty extends Google_Model
{
}
class Google_Service_Cloudresourcemanager_GetIamPolicyRequest extends Google_Model
{
}
class Google_Service_Cloudresourcemanager_ListOrganizationsResponse extends Google_Collection
{
protected $collection_key = 'organizations';
protected $internal_gapi_mappings = array(
);
public $nextPageToken;
protected $organizationsType = 'Google_Service_Cloudresourcemanager_Organization';
protected $organizationsDataType = 'array';
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
public function setOrganizations($organizations)
{
$this->organizations = $organizations;
}
public function getOrganizations()
{
return $this->organizations;
}
}
class Google_Service_Cloudresourcemanager_ListProjectsResponse extends Google_Collection
{
protected $collection_key = 'projects';
protected $internal_gapi_mappings = array(
);
public $nextPageToken;
protected $projectsType = 'Google_Service_Cloudresourcemanager_Project';
protected $projectsDataType = 'array';
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
public function setProjects($projects)
{
$this->projects = $projects;
}
public function getProjects()
{
return $this->projects;
}
}
class Google_Service_Cloudresourcemanager_Organization extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $displayName;
public $organizationId;
protected $ownerType = 'Google_Service_Cloudresourcemanager_OrganizationOwner';
protected $ownerDataType = '';
public function setDisplayName($displayName)
{
$this->displayName = $displayName;
}
public function getDisplayName()
{
return $this->displayName;
}
public function setOrganizationId($organizationId)
{
$this->organizationId = $organizationId;
}
public function getOrganizationId()
{
return $this->organizationId;
}
public function setOwner(Google_Service_Cloudresourcemanager_OrganizationOwner $owner)
{
$this->owner = $owner;
}
public function getOwner()
{
return $this->owner;
}
}
class Google_Service_Cloudresourcemanager_OrganizationOwner extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $directoryCustomerId;
public function setDirectoryCustomerId($directoryCustomerId)
{
$this->directoryCustomerId = $directoryCustomerId;
}
public function getDirectoryCustomerId()
{
return $this->directoryCustomerId;
}
}
class Google_Service_Cloudresourcemanager_Policy extends Google_Collection
{
protected $collection_key = 'bindings';
protected $internal_gapi_mappings = array(
);
protected $bindingsType = 'Google_Service_Cloudresourcemanager_Binding';
protected $bindingsDataType = 'array';
public $etag;
public $version;
public function setBindings($bindings)
{
$this->bindings = $bindings;
}
public function getBindings()
{
return $this->bindings;
}
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setVersion($version)
{
$this->version = $version;
}
public function getVersion()
{
return $this->version;
}
}
class Google_Service_Cloudresourcemanager_Project extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $createTime;
public $labels;
public $lifecycleState;
public $name;
protected $parentType = 'Google_Service_Cloudresourcemanager_ResourceId';
protected $parentDataType = '';
public $projectId;
public $projectNumber;
public function setCreateTime($createTime)
{
$this->createTime = $createTime;
}
public function getCreateTime()
{
return $this->createTime;
}
public function setLabels($labels)
{
$this->labels = $labels;
}
public function getLabels()
{
return $this->labels;
}
public function setLifecycleState($lifecycleState)
{
$this->lifecycleState = $lifecycleState;
}
public function getLifecycleState()
{
return $this->lifecycleState;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setParent(Google_Service_Cloudresourcemanager_ResourceId $parent)
{
$this->parent = $parent;
}
public function getParent()
{
return $this->parent;
}
public function setProjectId($projectId)
{
$this->projectId = $projectId;
}
public function getProjectId()
{
return $this->projectId;
}
public function setProjectNumber($projectNumber)
{
$this->projectNumber = $projectNumber;
}
public function getProjectNumber()
{
return $this->projectNumber;
}
}
class Google_Service_Cloudresourcemanager_ProjectLabels extends Google_Model
{
}
class Google_Service_Cloudresourcemanager_ResourceId extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $id;
public $type;
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setType($type)
{
$this->type = $type;
}
public function getType()
{
return $this->type;
}
}
class Google_Service_Cloudresourcemanager_SetIamPolicyRequest extends Google_Model
{
protected $internal_gapi_mappings = array(
);
protected $policyType = 'Google_Service_Cloudresourcemanager_Policy';
protected $policyDataType = '';
public function setPolicy(Google_Service_Cloudresourcemanager_Policy $policy)
{
$this->policy = $policy;
}
public function getPolicy()
{
return $this->policy;
}
}
class Google_Service_Cloudresourcemanager_TestIamPermissionsRequest extends Google_Collection
{
protected $collection_key = 'permissions';
protected $internal_gapi_mappings = array(
);
public $permissions;
public function setPermissions($permissions)
{
$this->permissions = $permissions;
}
public function getPermissions()
{
return $this->permissions;
}
}
class Google_Service_Cloudresourcemanager_TestIamPermissionsResponse extends Google_Collection
{
protected $collection_key = 'permissions';
protected $internal_gapi_mappings = array(
);
public $permissions;
public function setPermissions($permissions)
{
$this->permissions = $permissions;
}
public function getPermissions()
{
return $this->permissions;
}
}

53
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Cloudsearch.php vendored
View File

@ -1,53 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Cloudsearch (v1).
*
* <p>
* The Google Cloud Search API defines an application interface to index
* documents that contain structured data and to search those indexes. It
* supports full text search.</p>
*
* <p>
* For more information about this service, see the API
* <a href="" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Cloudsearch extends Google_Service
{
/**
* Constructs the internal representation of the Cloudsearch service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->servicePath = '';
$this->version = 'v1';
$this->serviceName = 'cloudsearch';
}
}

460
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Cloudtrace.php vendored
View File

@ -1,460 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Cloudtrace (v1).
*
* <p>
* The Google Cloud Trace API provides services for reading and writing runtime
* trace data for Cloud applications.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://cloud.google.com/tools/cloud-trace" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Cloudtrace extends Google_Service
{
/** View and manage your data across Google Cloud Platform services. */
const CLOUD_PLATFORM =
"https://www.googleapis.com/auth/cloud-platform";
public $projects;
public $projects_traces;
public $v1;
/**
* Constructs the internal representation of the Cloudtrace service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://cloudtrace.googleapis.com/';
$this->servicePath = '';
$this->version = 'v1';
$this->serviceName = 'cloudtrace';
$this->projects = new Google_Service_Cloudtrace_Projects_Resource(
$this,
$this->serviceName,
'projects',
array(
'methods' => array(
'patchTraces' => array(
'path' => 'v1/projects/{projectId}/traces',
'httpMethod' => 'PATCH',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
$this->projects_traces = new Google_Service_Cloudtrace_ProjectsTraces_Resource(
$this,
$this->serviceName,
'traces',
array(
'methods' => array(
'get' => array(
'path' => 'v1/projects/{projectId}/traces/{traceId}',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'traceId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1/projects/{projectId}/traces',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'orderBy' => array(
'location' => 'query',
'type' => 'string',
),
'pageSize' => array(
'location' => 'query',
'type' => 'integer',
),
'filter' => array(
'location' => 'query',
'type' => 'string',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'startTime' => array(
'location' => 'query',
'type' => 'string',
),
'endTime' => array(
'location' => 'query',
'type' => 'string',
),
'view' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
$this->v1 = new Google_Service_Cloudtrace_V1_Resource(
$this,
$this->serviceName,
'v1',
array(
'methods' => array(
'getDiscovery' => array(
'path' => 'v1/discovery',
'httpMethod' => 'GET',
'parameters' => array(
'labels' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'version' => array(
'location' => 'query',
'type' => 'string',
),
'args' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'format' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $cloudtraceService = new Google_Service_Cloudtrace(...);
* $projects = $cloudtraceService->projects;
* </code>
*/
class Google_Service_Cloudtrace_Projects_Resource extends Google_Service_Resource
{
/**
* Updates the existing traces specified by PatchTracesRequest and inserts the
* new traces. Any existing trace or span fields included in an update are
* overwritten by the update, and any additional fields in an update are merged
* with the existing trace data. (projects.patchTraces)
*
* @param string $projectId The project id of the trace to patch.
* @param Google_Traces $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudtrace_Empty
*/
public function patchTraces($projectId, Google_Service_Cloudtrace_Traces $postBody, $optParams = array())
{
$params = array('projectId' => $projectId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('patchTraces', array($params), "Google_Service_Cloudtrace_Empty");
}
}
/**
* The "traces" collection of methods.
* Typical usage is:
* <code>
* $cloudtraceService = new Google_Service_Cloudtrace(...);
* $traces = $cloudtraceService->traces;
* </code>
*/
class Google_Service_Cloudtrace_ProjectsTraces_Resource extends Google_Service_Resource
{
/**
* Gets one trace by id. (traces.get)
*
* @param string $projectId The project id of the trace to return.
* @param string $traceId The trace id of the trace to return.
* @param array $optParams Optional parameters.
* @return Google_Service_Cloudtrace_Trace
*/
public function get($projectId, $traceId, $optParams = array())
{
$params = array('projectId' => $projectId, 'traceId' => $traceId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Cloudtrace_Trace");
}
/**
* List traces matching the filter expression. (traces.listProjectsTraces)
*
* @param string $projectId The stringified-version of the project id.
* @param array $optParams Optional parameters.
*
* @opt_param string orderBy The trace field used to establish the order of
* traces returned by the ListTraces method. Possible options are: trace_id name
* (name field of root span) duration (different between end_time and start_time
* fields of root span) start (start_time field of root span) Descending order
* can be specified by appending "desc" to the sort field: name desc Only one
* sort field is permitted, though this may change in the future.
* @opt_param int pageSize Maximum number of topics to return. If not specified
* or <= 0, the implementation will select a reasonable value. The implemenation
* may always return fewer than the requested page_size.
* @opt_param string filter An optional filter for the request.
* @opt_param string pageToken The token identifying the page of results to
* return from the ListTraces method. If present, this value is should be taken
* from the next_page_token field of a previous ListTracesResponse.
* @opt_param string startTime End of the time interval (inclusive).
* @opt_param string endTime Start of the time interval (exclusive).
* @opt_param string view ViewType specifies the projection of the result.
* @return Google_Service_Cloudtrace_ListTracesResponse
*/
public function listProjectsTraces($projectId, $optParams = array())
{
$params = array('projectId' => $projectId);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Cloudtrace_ListTracesResponse");
}
}
/**
* The "v1" collection of methods.
* Typical usage is:
* <code>
* $cloudtraceService = new Google_Service_Cloudtrace(...);
* $v1 = $cloudtraceService->v1;
* </code>
*/
class Google_Service_Cloudtrace_V1_Resource extends Google_Service_Resource
{
/**
* Returns a discovery document in the specified `format`. The typeurl in the
* returned google.protobuf.Any value depends on the requested format.
* (v1.getDiscovery)
*
* @param array $optParams Optional parameters.
*
* @opt_param string labels A list of labels (like visibility) influencing the
* scope of the requested doc.
* @opt_param string version The API version of the requested discovery doc.
* @opt_param string args Any additional arguments.
* @opt_param string format The format requested for discovery.
*/
public function getDiscovery($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('getDiscovery', array($params));
}
}
class Google_Service_Cloudtrace_Empty extends Google_Model
{
}
class Google_Service_Cloudtrace_ListTracesResponse extends Google_Collection
{
protected $collection_key = 'traces';
protected $internal_gapi_mappings = array(
);
public $nextPageToken;
protected $tracesType = 'Google_Service_Cloudtrace_Trace';
protected $tracesDataType = 'array';
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
public function setTraces($traces)
{
$this->traces = $traces;
}
public function getTraces()
{
return $this->traces;
}
}
class Google_Service_Cloudtrace_Trace extends Google_Collection
{
protected $collection_key = 'spans';
protected $internal_gapi_mappings = array(
);
public $projectId;
protected $spansType = 'Google_Service_Cloudtrace_TraceSpan';
protected $spansDataType = 'array';
public $traceId;
public function setProjectId($projectId)
{
$this->projectId = $projectId;
}
public function getProjectId()
{
return $this->projectId;
}
public function setSpans($spans)
{
$this->spans = $spans;
}
public function getSpans()
{
return $this->spans;
}
public function setTraceId($traceId)
{
$this->traceId = $traceId;
}
public function getTraceId()
{
return $this->traceId;
}
}
class Google_Service_Cloudtrace_TraceSpan extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $endTime;
public $kind;
public $labels;
public $name;
public $parentSpanId;
public $spanId;
public $startTime;
public function setEndTime($endTime)
{
$this->endTime = $endTime;
}
public function getEndTime()
{
return $this->endTime;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setLabels($labels)
{
$this->labels = $labels;
}
public function getLabels()
{
return $this->labels;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setParentSpanId($parentSpanId)
{
$this->parentSpanId = $parentSpanId;
}
public function getParentSpanId()
{
return $this->parentSpanId;
}
public function setSpanId($spanId)
{
$this->spanId = $spanId;
}
public function getSpanId()
{
return $this->spanId;
}
public function setStartTime($startTime)
{
$this->startTime = $startTime;
}
public function getStartTime()
{
return $this->startTime;
}
}
class Google_Service_Cloudtrace_TraceSpanLabels extends Google_Model
{
}
class Google_Service_Cloudtrace_Traces extends Google_Collection
{
protected $collection_key = 'traces';
protected $internal_gapi_mappings = array(
);
protected $tracesType = 'Google_Service_Cloudtrace_Trace';
protected $tracesDataType = 'array';
public function setTraces($traces)
{
$this->traces = $traces;
}
public function getTraces()
{
return $this->traces;
}
}

17953
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Compute.php vendored
View File

File diff suppressed because it is too large Load Diff

1689
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Computeaccounts.php vendored
View File

File diff suppressed because it is too large Load Diff

913
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Container.php vendored
View File

@ -1,913 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Container (v1).
*
* <p>
* The Google Container Engine API is used for building and managing container
* based applications, powered by the open source Kubernetes technology.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://cloud.google.com/container-engine/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Container extends Google_Service
{
/** View and manage your data across Google Cloud Platform services. */
const CLOUD_PLATFORM =
"https://www.googleapis.com/auth/cloud-platform";
public $projects_zones;
public $projects_zones_clusters;
public $projects_zones_operations;
/**
* Constructs the internal representation of the Container service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://container.googleapis.com/';
$this->servicePath = '';
$this->version = 'v1';
$this->serviceName = 'container';
$this->projects_zones = new Google_Service_Container_ProjectsZones_Resource(
$this,
$this->serviceName,
'zones',
array(
'methods' => array(
'getServerconfig' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/serverconfig',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
$this->projects_zones_clusters = new Google_Service_Container_ProjectsZonesClusters_Resource(
$this,
$this->serviceName,
'clusters',
array(
'methods' => array(
'create' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/clusters',
'httpMethod' => 'POST',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'delete' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/clusters/{clusterId}',
'httpMethod' => 'DELETE',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'clusterId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'get' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/clusters/{clusterId}',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'clusterId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/clusters',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'update' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/clusters/{clusterId}',
'httpMethod' => 'PUT',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'clusterId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
$this->projects_zones_operations = new Google_Service_Container_ProjectsZonesOperations_Resource(
$this,
$this->serviceName,
'operations',
array(
'methods' => array(
'get' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/operations/{operationId}',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'operationId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'v1/projects/{projectId}/zones/{zone}/operations',
'httpMethod' => 'GET',
'parameters' => array(
'projectId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'zone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $containerService = new Google_Service_Container(...);
* $projects = $containerService->projects;
* </code>
*/
class Google_Service_Container_Projects_Resource extends Google_Service_Resource
{
}
/**
* The "zones" collection of methods.
* Typical usage is:
* <code>
* $containerService = new Google_Service_Container(...);
* $zones = $containerService->zones;
* </code>
*/
class Google_Service_Container_ProjectsZones_Resource extends Google_Service_Resource
{
/**
* Returns configuration info about the Container Engine service.
* (zones.getServerconfig)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) to return operations for, or "-" for
* all zones.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_ServerConfig
*/
public function getServerconfig($projectId, $zone, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone);
$params = array_merge($params, $optParams);
return $this->call('getServerconfig', array($params), "Google_Service_Container_ServerConfig");
}
}
/**
* The "clusters" collection of methods.
* Typical usage is:
* <code>
* $containerService = new Google_Service_Container(...);
* $clusters = $containerService->clusters;
* </code>
*/
class Google_Service_Container_ProjectsZonesClusters_Resource extends Google_Service_Resource
{
/**
* Creates a cluster, consisting of the specified number and type of Google
* Compute Engine instances, plus a Kubernetes master endpoint. By default, the
* cluster is created in the project's [default
* network](/compute/docs/networking#networks_1). One firewall is added for the
* cluster. After cluster creation, the cluster creates routes for each node to
* allow the containers on that node to communicate with all other instances in
* the cluster. Finally, an entry is added to the project's global metadata
* indicating which CIDR range is being used by the cluster. (clusters.create)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides.
* @param Google_CreateClusterRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Container_Operation
*/
public function create($projectId, $zone, Google_Service_Container_CreateClusterRequest $postBody, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('create', array($params), "Google_Service_Container_Operation");
}
/**
* Deletes the cluster, including the Kubernetes endpoint and all worker nodes.
* Firewalls and routes that were configured during cluster creation are also
* deleted. (clusters.delete)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides.
* @param string $clusterId The name of the cluster to delete.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_Operation
*/
public function delete($projectId, $zone, $clusterId, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone, 'clusterId' => $clusterId);
$params = array_merge($params, $optParams);
return $this->call('delete', array($params), "Google_Service_Container_Operation");
}
/**
* Gets a specific cluster. (clusters.get)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides.
* @param string $clusterId The name of the cluster to retrieve.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_Cluster
*/
public function get($projectId, $zone, $clusterId, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone, 'clusterId' => $clusterId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Container_Cluster");
}
/**
* Lists all clusters owned by a project in either the specified zone or all
* zones. (clusters.listProjectsZonesClusters)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides, or "-"
* for all zones.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_ListClustersResponse
*/
public function listProjectsZonesClusters($projectId, $zone, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Container_ListClustersResponse");
}
/**
* Update settings of a specific cluster. (clusters.update)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides.
* @param string $clusterId The name of the cluster to upgrade.
* @param Google_UpdateClusterRequest $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Container_Operation
*/
public function update($projectId, $zone, $clusterId, Google_Service_Container_UpdateClusterRequest $postBody, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone, 'clusterId' => $clusterId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_Container_Operation");
}
}
/**
* The "operations" collection of methods.
* Typical usage is:
* <code>
* $containerService = new Google_Service_Container(...);
* $operations = $containerService->operations;
* </code>
*/
class Google_Service_Container_ProjectsZonesOperations_Resource extends Google_Service_Resource
{
/**
* Gets the specified operation. (operations.get)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) in which the cluster resides.
* @param string $operationId The server-assigned `name` of the operation.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_Operation
*/
public function get($projectId, $zone, $operationId, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone, 'operationId' => $operationId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Container_Operation");
}
/**
* Lists all operations in a project in a specific zone or all zones.
* (operations.listProjectsZonesOperations)
*
* @param string $projectId The Google Developers Console [project ID or project
* number](https://developers.google.com/console/help/new/#projectnumber).
* @param string $zone The name of the Google Compute Engine
* [zone](/compute/docs/zones#available) to return operations for, or "-" for
* all zones.
* @param array $optParams Optional parameters.
* @return Google_Service_Container_ListOperationsResponse
*/
public function listProjectsZonesOperations($projectId, $zone, $optParams = array())
{
$params = array('projectId' => $projectId, 'zone' => $zone);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Container_ListOperationsResponse");
}
}
class Google_Service_Container_Cluster extends Google_Collection
{
protected $collection_key = 'instanceGroupUrls';
protected $internal_gapi_mappings = array(
);
public $clusterIpv4Cidr;
public $createTime;
public $currentMasterVersion;
public $currentNodeVersion;
public $description;
public $endpoint;
public $initialClusterVersion;
public $initialNodeCount;
public $instanceGroupUrls;
public $loggingService;
protected $masterAuthType = 'Google_Service_Container_MasterAuth';
protected $masterAuthDataType = '';
public $monitoringService;
public $name;
public $network;
protected $nodeConfigType = 'Google_Service_Container_NodeConfig';
protected $nodeConfigDataType = '';
public $nodeIpv4CidrSize;
public $selfLink;
public $servicesIpv4Cidr;
public $status;
public $statusMessage;
public $zone;
public function setClusterIpv4Cidr($clusterIpv4Cidr)
{
$this->clusterIpv4Cidr = $clusterIpv4Cidr;
}
public function getClusterIpv4Cidr()
{
return $this->clusterIpv4Cidr;
}
public function setCreateTime($createTime)
{
$this->createTime = $createTime;
}
public function getCreateTime()
{
return $this->createTime;
}
public function setCurrentMasterVersion($currentMasterVersion)
{
$this->currentMasterVersion = $currentMasterVersion;
}
public function getCurrentMasterVersion()
{
return $this->currentMasterVersion;
}
public function setCurrentNodeVersion($currentNodeVersion)
{
$this->currentNodeVersion = $currentNodeVersion;
}
public function getCurrentNodeVersion()
{
return $this->currentNodeVersion;
}
public function setDescription($description)
{
$this->description = $description;
}
public function getDescription()
{
return $this->description;
}
public function setEndpoint($endpoint)
{
$this->endpoint = $endpoint;
}
public function getEndpoint()
{
return $this->endpoint;
}
public function setInitialClusterVersion($initialClusterVersion)
{
$this->initialClusterVersion = $initialClusterVersion;
}
public function getInitialClusterVersion()
{
return $this->initialClusterVersion;
}
public function setInitialNodeCount($initialNodeCount)
{
$this->initialNodeCount = $initialNodeCount;
}
public function getInitialNodeCount()
{
return $this->initialNodeCount;
}
public function setInstanceGroupUrls($instanceGroupUrls)
{
$this->instanceGroupUrls = $instanceGroupUrls;
}
public function getInstanceGroupUrls()
{
return $this->instanceGroupUrls;
}
public function setLoggingService($loggingService)
{
$this->loggingService = $loggingService;
}
public function getLoggingService()
{
return $this->loggingService;
}
public function setMasterAuth(Google_Service_Container_MasterAuth $masterAuth)
{
$this->masterAuth = $masterAuth;
}
public function getMasterAuth()
{
return $this->masterAuth;
}
public function setMonitoringService($monitoringService)
{
$this->monitoringService = $monitoringService;
}
public function getMonitoringService()
{
return $this->monitoringService;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setNetwork($network)
{
$this->network = $network;
}
public function getNetwork()
{
return $this->network;
}
public function setNodeConfig(Google_Service_Container_NodeConfig $nodeConfig)
{
$this->nodeConfig = $nodeConfig;
}
public function getNodeConfig()
{
return $this->nodeConfig;
}
public function setNodeIpv4CidrSize($nodeIpv4CidrSize)
{
$this->nodeIpv4CidrSize = $nodeIpv4CidrSize;
}
public function getNodeIpv4CidrSize()
{
return $this->nodeIpv4CidrSize;
}
public function setSelfLink($selfLink)
{
$this->selfLink = $selfLink;
}
public function getSelfLink()
{
return $this->selfLink;
}
public function setServicesIpv4Cidr($servicesIpv4Cidr)
{
$this->servicesIpv4Cidr = $servicesIpv4Cidr;
}
public function getServicesIpv4Cidr()
{
return $this->servicesIpv4Cidr;
}
public function setStatus($status)
{
$this->status = $status;
}
public function getStatus()
{
return $this->status;
}
public function setStatusMessage($statusMessage)
{
$this->statusMessage = $statusMessage;
}
public function getStatusMessage()
{
return $this->statusMessage;
}
public function setZone($zone)
{
$this->zone = $zone;
}
public function getZone()
{
return $this->zone;
}
}
class Google_Service_Container_ClusterUpdate extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $desiredNodeVersion;
public function setDesiredNodeVersion($desiredNodeVersion)
{
$this->desiredNodeVersion = $desiredNodeVersion;
}
public function getDesiredNodeVersion()
{
return $this->desiredNodeVersion;
}
}
class Google_Service_Container_CreateClusterRequest extends Google_Model
{
protected $internal_gapi_mappings = array(
);
protected $clusterType = 'Google_Service_Container_Cluster';
protected $clusterDataType = '';
public function setCluster(Google_Service_Container_Cluster $cluster)
{
$this->cluster = $cluster;
}
public function getCluster()
{
return $this->cluster;
}
}
class Google_Service_Container_ListClustersResponse extends Google_Collection
{
protected $collection_key = 'clusters';
protected $internal_gapi_mappings = array(
);
protected $clustersType = 'Google_Service_Container_Cluster';
protected $clustersDataType = 'array';
public function setClusters($clusters)
{
$this->clusters = $clusters;
}
public function getClusters()
{
return $this->clusters;
}
}
class Google_Service_Container_ListOperationsResponse extends Google_Collection
{
protected $collection_key = 'operations';
protected $internal_gapi_mappings = array(
);
protected $operationsType = 'Google_Service_Container_Operation';
protected $operationsDataType = 'array';
public function setOperations($operations)
{
$this->operations = $operations;
}
public function getOperations()
{
return $this->operations;
}
}
class Google_Service_Container_MasterAuth extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $clientCertificate;
public $clientKey;
public $clusterCaCertificate;
public $password;
public $username;
public function setClientCertificate($clientCertificate)
{
$this->clientCertificate = $clientCertificate;
}
public function getClientCertificate()
{
return $this->clientCertificate;
}
public function setClientKey($clientKey)
{
$this->clientKey = $clientKey;
}
public function getClientKey()
{
return $this->clientKey;
}
public function setClusterCaCertificate($clusterCaCertificate)
{
$this->clusterCaCertificate = $clusterCaCertificate;
}
public function getClusterCaCertificate()
{
return $this->clusterCaCertificate;
}
public function setPassword($password)
{
$this->password = $password;
}
public function getPassword()
{
return $this->password;
}
public function setUsername($username)
{
$this->username = $username;
}
public function getUsername()
{
return $this->username;
}
}
class Google_Service_Container_NodeConfig extends Google_Collection
{
protected $collection_key = 'oauthScopes';
protected $internal_gapi_mappings = array(
);
public $diskSizeGb;
public $machineType;
public $oauthScopes;
public function setDiskSizeGb($diskSizeGb)
{
$this->diskSizeGb = $diskSizeGb;
}
public function getDiskSizeGb()
{
return $this->diskSizeGb;
}
public function setMachineType($machineType)
{
$this->machineType = $machineType;
}
public function getMachineType()
{
return $this->machineType;
}
public function setOauthScopes($oauthScopes)
{
$this->oauthScopes = $oauthScopes;
}
public function getOauthScopes()
{
return $this->oauthScopes;
}
}
class Google_Service_Container_Operation extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $name;
public $operationType;
public $selfLink;
public $status;
public $statusMessage;
public $targetLink;
public $zone;
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setOperationType($operationType)
{
$this->operationType = $operationType;
}
public function getOperationType()
{
return $this->operationType;
}
public function setSelfLink($selfLink)
{
$this->selfLink = $selfLink;
}
public function getSelfLink()
{
return $this->selfLink;
}
public function setStatus($status)
{
$this->status = $status;
}
public function getStatus()
{
return $this->status;
}
public function setStatusMessage($statusMessage)
{
$this->statusMessage = $statusMessage;
}
public function getStatusMessage()
{
return $this->statusMessage;
}
public function setTargetLink($targetLink)
{
$this->targetLink = $targetLink;
}
public function getTargetLink()
{
return $this->targetLink;
}
public function setZone($zone)
{
$this->zone = $zone;
}
public function getZone()
{
return $this->zone;
}
}
class Google_Service_Container_ServerConfig extends Google_Collection
{
protected $collection_key = 'validNodeVersions';
protected $internal_gapi_mappings = array(
);
public $defaultClusterVersion;
public $validNodeVersions;
public function setDefaultClusterVersion($defaultClusterVersion)
{
$this->defaultClusterVersion = $defaultClusterVersion;
}
public function getDefaultClusterVersion()
{
return $this->defaultClusterVersion;
}
public function setValidNodeVersions($validNodeVersions)
{
$this->validNodeVersions = $validNodeVersions;
}
public function getValidNodeVersions()
{
return $this->validNodeVersions;
}
}
class Google_Service_Container_UpdateClusterRequest extends Google_Model
{
protected $internal_gapi_mappings = array(
);
protected $updateType = 'Google_Service_Container_ClusterUpdate';
protected $updateDataType = '';
public function setUpdate(Google_Service_Container_ClusterUpdate $update)
{
$this->update = $update;
}
public function getUpdate()
{
return $this->update;
}
}

1570
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Coordinate.php vendored
View File

File diff suppressed because it is too large Load Diff

1277
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Customsearch.php vendored
View File

File diff suppressed because it is too large Load Diff

554
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/DataTransfer.php vendored
View File

@ -1,554 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for DataTransfer (datatransfer_v1).
*
* <p>
* Admin Data Transfer API lets you transfer user data from one user to another.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/admin-sdk/data-transfer/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_DataTransfer extends Google_Service
{
/** View and manage data transfers between users in your organization. */
const ADMIN_DATATRANSFER =
"https://www.googleapis.com/auth/admin.datatransfer";
/** View data transfers between users in your organization. */
const ADMIN_DATATRANSFER_READONLY =
"https://www.googleapis.com/auth/admin.datatransfer.readonly";
public $applications;
public $transfers;
/**
* Constructs the internal representation of the DataTransfer service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'admin/datatransfer/v1/';
$this->version = 'datatransfer_v1';
$this->serviceName = 'admin';
$this->applications = new Google_Service_DataTransfer_Applications_Resource(
$this,
$this->serviceName,
'applications',
array(
'methods' => array(
'get' => array(
'path' => 'applications/{applicationId}',
'httpMethod' => 'GET',
'parameters' => array(
'applicationId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => 'applications',
'httpMethod' => 'GET',
'parameters' => array(
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'customerId' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
),
),
)
)
);
$this->transfers = new Google_Service_DataTransfer_Transfers_Resource(
$this,
$this->serviceName,
'transfers',
array(
'methods' => array(
'get' => array(
'path' => 'transfers/{dataTransferId}',
'httpMethod' => 'GET',
'parameters' => array(
'dataTransferId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'insert' => array(
'path' => 'transfers',
'httpMethod' => 'POST',
'parameters' => array(),
),'list' => array(
'path' => 'transfers',
'httpMethod' => 'GET',
'parameters' => array(
'status' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
'newOwnerUserId' => array(
'location' => 'query',
'type' => 'string',
),
'oldOwnerUserId' => array(
'location' => 'query',
'type' => 'string',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'customerId' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "applications" collection of methods.
* Typical usage is:
* <code>
* $adminService = new Google_Service_DataTransfer(...);
* $applications = $adminService->applications;
* </code>
*/
class Google_Service_DataTransfer_Applications_Resource extends Google_Service_Resource
{
/**
* Retrieves information about an application for the given application ID.
* (applications.get)
*
* @param string $applicationId ID of the application resource to be retrieved.
* @param array $optParams Optional parameters.
* @return Google_Service_DataTransfer_Application
*/
public function get($applicationId, $optParams = array())
{
$params = array('applicationId' => $applicationId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_DataTransfer_Application");
}
/**
* Lists the applications available for data transfer for a customer.
* (applications.listApplications)
*
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken Token to specify next page in the list.
* @opt_param string customerId Immutable ID of the Google Apps account.
* @opt_param string maxResults Maximum number of results to return. Default is
* 100.
* @return Google_Service_DataTransfer_ApplicationsListResponse
*/
public function listApplications($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_DataTransfer_ApplicationsListResponse");
}
}
/**
* The "transfers" collection of methods.
* Typical usage is:
* <code>
* $adminService = new Google_Service_DataTransfer(...);
* $transfers = $adminService->transfers;
* </code>
*/
class Google_Service_DataTransfer_Transfers_Resource extends Google_Service_Resource
{
/**
* Retrieves a data transfer request by its resource ID. (transfers.get)
*
* @param string $dataTransferId ID of the resource to be retrieved. This is
* returned in the response from the insert method.
* @param array $optParams Optional parameters.
* @return Google_Service_DataTransfer_DataTransfer
*/
public function get($dataTransferId, $optParams = array())
{
$params = array('dataTransferId' => $dataTransferId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_DataTransfer_DataTransfer");
}
/**
* Inserts a data transfer request. (transfers.insert)
*
* @param Google_DataTransfer $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_DataTransfer_DataTransfer
*/
public function insert(Google_Service_DataTransfer_DataTransfer $postBody, $optParams = array())
{
$params = array('postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('insert', array($params), "Google_Service_DataTransfer_DataTransfer");
}
/**
* Lists the transfers for a customer by source user, destination user, or
* status. (transfers.listTransfers)
*
* @param array $optParams Optional parameters.
*
* @opt_param string status Status of the transfer.
* @opt_param int maxResults Maximum number of results to return. Default is
* 100.
* @opt_param string newOwnerUserId Destination user's profile ID.
* @opt_param string oldOwnerUserId Source user's profile ID.
* @opt_param string pageToken Token to specify the next page in the list.
* @opt_param string customerId Immutable ID of the Google Apps account.
* @return Google_Service_DataTransfer_DataTransfersListResponse
*/
public function listTransfers($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_DataTransfer_DataTransfersListResponse");
}
}
class Google_Service_DataTransfer_Application extends Google_Collection
{
protected $collection_key = 'transferParams';
protected $internal_gapi_mappings = array(
);
public $etag;
public $id;
public $kind;
public $name;
protected $transferParamsType = 'Google_Service_DataTransfer_ApplicationTransferParam';
protected $transferParamsDataType = 'array';
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setTransferParams($transferParams)
{
$this->transferParams = $transferParams;
}
public function getTransferParams()
{
return $this->transferParams;
}
}
class Google_Service_DataTransfer_ApplicationDataTransfer extends Google_Collection
{
protected $collection_key = 'applicationTransferParams';
protected $internal_gapi_mappings = array(
);
public $applicationId;
protected $applicationTransferParamsType = 'Google_Service_DataTransfer_ApplicationTransferParam';
protected $applicationTransferParamsDataType = 'array';
public $applicationTransferStatus;
public function setApplicationId($applicationId)
{
$this->applicationId = $applicationId;
}
public function getApplicationId()
{
return $this->applicationId;
}
public function setApplicationTransferParams($applicationTransferParams)
{
$this->applicationTransferParams = $applicationTransferParams;
}
public function getApplicationTransferParams()
{
return $this->applicationTransferParams;
}
public function setApplicationTransferStatus($applicationTransferStatus)
{
$this->applicationTransferStatus = $applicationTransferStatus;
}
public function getApplicationTransferStatus()
{
return $this->applicationTransferStatus;
}
}
class Google_Service_DataTransfer_ApplicationTransferParam extends Google_Collection
{
protected $collection_key = 'value';
protected $internal_gapi_mappings = array(
);
public $key;
public $value;
public function setKey($key)
{
$this->key = $key;
}
public function getKey()
{
return $this->key;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
class Google_Service_DataTransfer_ApplicationsListResponse extends Google_Collection
{
protected $collection_key = 'applications';
protected $internal_gapi_mappings = array(
);
protected $applicationsType = 'Google_Service_DataTransfer_Application';
protected $applicationsDataType = 'array';
public $etag;
public $kind;
public $nextPageToken;
public function setApplications($applications)
{
$this->applications = $applications;
}
public function getApplications()
{
return $this->applications;
}
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}
class Google_Service_DataTransfer_DataTransfer extends Google_Collection
{
protected $collection_key = 'applicationDataTransfers';
protected $internal_gapi_mappings = array(
);
protected $applicationDataTransfersType = 'Google_Service_DataTransfer_ApplicationDataTransfer';
protected $applicationDataTransfersDataType = 'array';
public $etag;
public $id;
public $kind;
public $newOwnerUserId;
public $oldOwnerUserId;
public $overallTransferStatusCode;
public $requestTime;
public function setApplicationDataTransfers($applicationDataTransfers)
{
$this->applicationDataTransfers = $applicationDataTransfers;
}
public function getApplicationDataTransfers()
{
return $this->applicationDataTransfers;
}
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNewOwnerUserId($newOwnerUserId)
{
$this->newOwnerUserId = $newOwnerUserId;
}
public function getNewOwnerUserId()
{
return $this->newOwnerUserId;
}
public function setOldOwnerUserId($oldOwnerUserId)
{
$this->oldOwnerUserId = $oldOwnerUserId;
}
public function getOldOwnerUserId()
{
return $this->oldOwnerUserId;
}
public function setOverallTransferStatusCode($overallTransferStatusCode)
{
$this->overallTransferStatusCode = $overallTransferStatusCode;
}
public function getOverallTransferStatusCode()
{
return $this->overallTransferStatusCode;
}
public function setRequestTime($requestTime)
{
$this->requestTime = $requestTime;
}
public function getRequestTime()
{
return $this->requestTime;
}
}
class Google_Service_DataTransfer_DataTransfersListResponse extends Google_Collection
{
protected $collection_key = 'dataTransfers';
protected $internal_gapi_mappings = array(
);
protected $dataTransfersType = 'Google_Service_DataTransfer_DataTransfer';
protected $dataTransfersDataType = 'array';
public $etag;
public $kind;
public $nextPageToken;
public function setDataTransfers($dataTransfers)
{
$this->dataTransfers = $dataTransfers;
}
public function getDataTransfers()
{
return $this->dataTransfers;
}
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}

3708
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Dataflow.php vendored
View File

File diff suppressed because it is too large Load Diff

1525
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Datastore.php vendored
View File

File diff suppressed because it is too large Load Diff

2019
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/DeploymentManager.php vendored
View File

File diff suppressed because it is too large Load Diff

21443
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Dfareporting.php vendored
View File

File diff suppressed because it is too large Load Diff

7180
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Directory.php vendored
View File

File diff suppressed because it is too large Load Diff

926
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Dns.php vendored
View File

@ -1,926 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Dns (v1).
*
* <p>
* The Google Cloud DNS API provides services for configuring and serving
* authoritative DNS records.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/cloud-dns" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Dns extends Google_Service
{
/** View and manage your data across Google Cloud Platform services. */
const CLOUD_PLATFORM =
"https://www.googleapis.com/auth/cloud-platform";
/** View your data across Google Cloud Platform services. */
const CLOUD_PLATFORM_READ_ONLY =
"https://www.googleapis.com/auth/cloud-platform.read-only";
/** View your DNS records hosted by Google Cloud DNS. */
const NDEV_CLOUDDNS_READONLY =
"https://www.googleapis.com/auth/ndev.clouddns.readonly";
/** View and manage your DNS records hosted by Google Cloud DNS. */
const NDEV_CLOUDDNS_READWRITE =
"https://www.googleapis.com/auth/ndev.clouddns.readwrite";
public $changes;
public $managedZones;
public $projects;
public $resourceRecordSets;
/**
* Constructs the internal representation of the Dns service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'dns/v1/projects/';
$this->version = 'v1';
$this->serviceName = 'dns';
$this->changes = new Google_Service_Dns_Changes_Resource(
$this,
$this->serviceName,
'changes',
array(
'methods' => array(
'create' => array(
'path' => '{project}/managedZones/{managedZone}/changes',
'httpMethod' => 'POST',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'get' => array(
'path' => '{project}/managedZones/{managedZone}/changes/{changeId}',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'changeId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => '{project}/managedZones/{managedZone}/changes',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'sortBy' => array(
'location' => 'query',
'type' => 'string',
),
'sortOrder' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
$this->managedZones = new Google_Service_Dns_ManagedZones_Resource(
$this,
$this->serviceName,
'managedZones',
array(
'methods' => array(
'create' => array(
'path' => '{project}/managedZones',
'httpMethod' => 'POST',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'delete' => array(
'path' => '{project}/managedZones/{managedZone}',
'httpMethod' => 'DELETE',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'get' => array(
'path' => '{project}/managedZones/{managedZone}',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'list' => array(
'path' => '{project}/managedZones',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'dnsName' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
),
),
)
)
);
$this->projects = new Google_Service_Dns_Projects_Resource(
$this,
$this->serviceName,
'projects',
array(
'methods' => array(
'get' => array(
'path' => '{project}',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
$this->resourceRecordSets = new Google_Service_Dns_ResourceRecordSets_Resource(
$this,
$this->serviceName,
'resourceRecordSets',
array(
'methods' => array(
'list' => array(
'path' => '{project}/managedZones/{managedZone}/rrsets',
'httpMethod' => 'GET',
'parameters' => array(
'project' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'managedZone' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'name' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'type' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
}
/**
* The "changes" collection of methods.
* Typical usage is:
* <code>
* $dnsService = new Google_Service_Dns(...);
* $changes = $dnsService->changes;
* </code>
*/
class Google_Service_Dns_Changes_Resource extends Google_Service_Resource
{
/**
* Atomically update the ResourceRecordSet collection. (changes.create)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param Google_Change $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Dns_Change
*/
public function create($project, $managedZone, Google_Service_Dns_Change $postBody, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('create', array($params), "Google_Service_Dns_Change");
}
/**
* Fetch the representation of an existing Change. (changes.get)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param string $changeId The identifier of the requested change, from a
* previous ResourceRecordSetsChangeResponse.
* @param array $optParams Optional parameters.
* @return Google_Service_Dns_Change
*/
public function get($project, $managedZone, $changeId, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone, 'changeId' => $changeId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Dns_Change");
}
/**
* Enumerate Changes to a ResourceRecordSet collection. (changes.listChanges)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param array $optParams Optional parameters.
*
* @opt_param int maxResults Optional. Maximum number of results to be returned.
* If unspecified, the server will decide how many results to return.
* @opt_param string pageToken Optional. A tag returned by a previous list
* request that was truncated. Use this parameter to continue a previous list
* request.
* @opt_param string sortBy Sorting criterion. The only supported value is
* change sequence.
* @opt_param string sortOrder Sorting order direction: 'ascending' or
* 'descending'.
* @return Google_Service_Dns_ChangesListResponse
*/
public function listChanges($project, $managedZone, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Dns_ChangesListResponse");
}
}
/**
* The "managedZones" collection of methods.
* Typical usage is:
* <code>
* $dnsService = new Google_Service_Dns(...);
* $managedZones = $dnsService->managedZones;
* </code>
*/
class Google_Service_Dns_ManagedZones_Resource extends Google_Service_Resource
{
/**
* Create a new ManagedZone. (managedZones.create)
*
* @param string $project Identifies the project addressed by this request.
* @param Google_ManagedZone $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Dns_ManagedZone
*/
public function create($project, Google_Service_Dns_ManagedZone $postBody, $optParams = array())
{
$params = array('project' => $project, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('create', array($params), "Google_Service_Dns_ManagedZone");
}
/**
* Delete a previously created ManagedZone. (managedZones.delete)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param array $optParams Optional parameters.
*/
public function delete($project, $managedZone, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone);
$params = array_merge($params, $optParams);
return $this->call('delete', array($params));
}
/**
* Fetch the representation of an existing ManagedZone. (managedZones.get)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param array $optParams Optional parameters.
* @return Google_Service_Dns_ManagedZone
*/
public function get($project, $managedZone, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Dns_ManagedZone");
}
/**
* Enumerate ManagedZones that have been created but not yet deleted.
* (managedZones.listManagedZones)
*
* @param string $project Identifies the project addressed by this request.
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken Optional. A tag returned by a previous list
* request that was truncated. Use this parameter to continue a previous list
* request.
* @opt_param string dnsName Restricts the list to return only zones with this
* domain name.
* @opt_param int maxResults Optional. Maximum number of results to be returned.
* If unspecified, the server will decide how many results to return.
* @return Google_Service_Dns_ManagedZonesListResponse
*/
public function listManagedZones($project, $optParams = array())
{
$params = array('project' => $project);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Dns_ManagedZonesListResponse");
}
}
/**
* The "projects" collection of methods.
* Typical usage is:
* <code>
* $dnsService = new Google_Service_Dns(...);
* $projects = $dnsService->projects;
* </code>
*/
class Google_Service_Dns_Projects_Resource extends Google_Service_Resource
{
/**
* Fetch the representation of an existing Project. (projects.get)
*
* @param string $project Identifies the project addressed by this request.
* @param array $optParams Optional parameters.
* @return Google_Service_Dns_Project
*/
public function get($project, $optParams = array())
{
$params = array('project' => $project);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Dns_Project");
}
}
/**
* The "resourceRecordSets" collection of methods.
* Typical usage is:
* <code>
* $dnsService = new Google_Service_Dns(...);
* $resourceRecordSets = $dnsService->resourceRecordSets;
* </code>
*/
class Google_Service_Dns_ResourceRecordSets_Resource extends Google_Service_Resource
{
/**
* Enumerate ResourceRecordSets that have been created but not yet deleted.
* (resourceRecordSets.listResourceRecordSets)
*
* @param string $project Identifies the project addressed by this request.
* @param string $managedZone Identifies the managed zone addressed by this
* request. Can be the managed zone name or id.
* @param array $optParams Optional parameters.
*
* @opt_param string name Restricts the list to return only records with this
* fully qualified domain name.
* @opt_param int maxResults Optional. Maximum number of results to be returned.
* If unspecified, the server will decide how many results to return.
* @opt_param string pageToken Optional. A tag returned by a previous list
* request that was truncated. Use this parameter to continue a previous list
* request.
* @opt_param string type Restricts the list to return only records of this
* type. If present, the "name" parameter must also be present.
* @return Google_Service_Dns_ResourceRecordSetsListResponse
*/
public function listResourceRecordSets($project, $managedZone, $optParams = array())
{
$params = array('project' => $project, 'managedZone' => $managedZone);
$params = array_merge($params, $optParams);
return $this->call('list', array($params), "Google_Service_Dns_ResourceRecordSetsListResponse");
}
}
class Google_Service_Dns_Change extends Google_Collection
{
protected $collection_key = 'deletions';
protected $internal_gapi_mappings = array(
);
protected $additionsType = 'Google_Service_Dns_ResourceRecordSet';
protected $additionsDataType = 'array';
protected $deletionsType = 'Google_Service_Dns_ResourceRecordSet';
protected $deletionsDataType = 'array';
public $id;
public $kind;
public $startTime;
public $status;
public function setAdditions($additions)
{
$this->additions = $additions;
}
public function getAdditions()
{
return $this->additions;
}
public function setDeletions($deletions)
{
$this->deletions = $deletions;
}
public function getDeletions()
{
return $this->deletions;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setStartTime($startTime)
{
$this->startTime = $startTime;
}
public function getStartTime()
{
return $this->startTime;
}
public function setStatus($status)
{
$this->status = $status;
}
public function getStatus()
{
return $this->status;
}
}
class Google_Service_Dns_ChangesListResponse extends Google_Collection
{
protected $collection_key = 'changes';
protected $internal_gapi_mappings = array(
);
protected $changesType = 'Google_Service_Dns_Change';
protected $changesDataType = 'array';
public $kind;
public $nextPageToken;
public function setChanges($changes)
{
$this->changes = $changes;
}
public function getChanges()
{
return $this->changes;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}
class Google_Service_Dns_ManagedZone extends Google_Collection
{
protected $collection_key = 'nameServers';
protected $internal_gapi_mappings = array(
);
public $creationTime;
public $description;
public $dnsName;
public $id;
public $kind;
public $name;
public $nameServerSet;
public $nameServers;
public function setCreationTime($creationTime)
{
$this->creationTime = $creationTime;
}
public function getCreationTime()
{
return $this->creationTime;
}
public function setDescription($description)
{
$this->description = $description;
}
public function getDescription()
{
return $this->description;
}
public function setDnsName($dnsName)
{
$this->dnsName = $dnsName;
}
public function getDnsName()
{
return $this->dnsName;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setNameServerSet($nameServerSet)
{
$this->nameServerSet = $nameServerSet;
}
public function getNameServerSet()
{
return $this->nameServerSet;
}
public function setNameServers($nameServers)
{
$this->nameServers = $nameServers;
}
public function getNameServers()
{
return $this->nameServers;
}
}
class Google_Service_Dns_ManagedZonesListResponse extends Google_Collection
{
protected $collection_key = 'managedZones';
protected $internal_gapi_mappings = array(
);
public $kind;
protected $managedZonesType = 'Google_Service_Dns_ManagedZone';
protected $managedZonesDataType = 'array';
public $nextPageToken;
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setManagedZones($managedZones)
{
$this->managedZones = $managedZones;
}
public function getManagedZones()
{
return $this->managedZones;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}
class Google_Service_Dns_Project extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $id;
public $kind;
public $number;
protected $quotaType = 'Google_Service_Dns_Quota';
protected $quotaDataType = '';
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNumber($number)
{
$this->number = $number;
}
public function getNumber()
{
return $this->number;
}
public function setQuota(Google_Service_Dns_Quota $quota)
{
$this->quota = $quota;
}
public function getQuota()
{
return $this->quota;
}
}
class Google_Service_Dns_Quota extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $kind;
public $managedZones;
public $resourceRecordsPerRrset;
public $rrsetAdditionsPerChange;
public $rrsetDeletionsPerChange;
public $rrsetsPerManagedZone;
public $totalRrdataSizePerChange;
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setManagedZones($managedZones)
{
$this->managedZones = $managedZones;
}
public function getManagedZones()
{
return $this->managedZones;
}
public function setResourceRecordsPerRrset($resourceRecordsPerRrset)
{
$this->resourceRecordsPerRrset = $resourceRecordsPerRrset;
}
public function getResourceRecordsPerRrset()
{
return $this->resourceRecordsPerRrset;
}
public function setRrsetAdditionsPerChange($rrsetAdditionsPerChange)
{
$this->rrsetAdditionsPerChange = $rrsetAdditionsPerChange;
}
public function getRrsetAdditionsPerChange()
{
return $this->rrsetAdditionsPerChange;
}
public function setRrsetDeletionsPerChange($rrsetDeletionsPerChange)
{
$this->rrsetDeletionsPerChange = $rrsetDeletionsPerChange;
}
public function getRrsetDeletionsPerChange()
{
return $this->rrsetDeletionsPerChange;
}
public function setRrsetsPerManagedZone($rrsetsPerManagedZone)
{
$this->rrsetsPerManagedZone = $rrsetsPerManagedZone;
}
public function getRrsetsPerManagedZone()
{
return $this->rrsetsPerManagedZone;
}
public function setTotalRrdataSizePerChange($totalRrdataSizePerChange)
{
$this->totalRrdataSizePerChange = $totalRrdataSizePerChange;
}
public function getTotalRrdataSizePerChange()
{
return $this->totalRrdataSizePerChange;
}
}
class Google_Service_Dns_ResourceRecordSet extends Google_Collection
{
protected $collection_key = 'rrdatas';
protected $internal_gapi_mappings = array(
);
public $kind;
public $name;
public $rrdatas;
public $ttl;
public $type;
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setRrdatas($rrdatas)
{
$this->rrdatas = $rrdatas;
}
public function getRrdatas()
{
return $this->rrdatas;
}
public function setTtl($ttl)
{
$this->ttl = $ttl;
}
public function getTtl()
{
return $this->ttl;
}
public function setType($type)
{
$this->type = $type;
}
public function getType()
{
return $this->type;
}
}
class Google_Service_Dns_ResourceRecordSetsListResponse extends Google_Collection
{
protected $collection_key = 'rrsets';
protected $internal_gapi_mappings = array(
);
public $kind;
public $nextPageToken;
protected $rrsetsType = 'Google_Service_Dns_ResourceRecordSet';
protected $rrsetsDataType = 'array';
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
public function setRrsets($rrsets)
{
$this->rrsets = $rrsets;
}
public function getRrsets()
{
return $this->rrsets;
}
}

1085
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/DoubleClickBidManager.php vendored
View File

File diff suppressed because it is too large Load Diff

1543
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Doubleclicksearch.php vendored
View File

File diff suppressed because it is too large Load Diff

5775
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Drive.php vendored
View File

File diff suppressed because it is too large Load Diff

105
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Exception.php vendored
View File

@ -1,105 +0,0 @@
<?php
/*
* Copyright 2014 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
if (!class_exists('Google_Client')) {
require_once dirname(__FILE__) . '/../autoload.php';
}
class Google_Service_Exception extends Google_Exception implements Google_Task_Retryable
{
/**
* Optional list of errors returned in a JSON body of an HTTP error response.
*/
protected $errors = array();
/**
* @var array $retryMap Map of errors with retry counts.
*/
private $retryMap = array();
/**
* Override default constructor to add the ability to set $errors and a retry
* map.
*
* @param string $message
* @param int $code
* @param Exception|null $previous
* @param [{string, string}] errors List of errors returned in an HTTP
* response. Defaults to [].
* @param array|null $retryMap Map of errors with retry counts.
*/
public function __construct(
$message,
$code = 0,
Exception $previous = null,
$errors = array(),
array $retryMap = null
) {
if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
parent::__construct($message, $code, $previous);
} else {
parent::__construct($message, $code);
}
$this->errors = $errors;
if (is_array($retryMap)) {
$this->retryMap = $retryMap;
}
}
/**
* An example of the possible errors returned.
*
* {
* "domain": "global",
* "reason": "authError",
* "message": "Invalid Credentials",
* "locationType": "header",
* "location": "Authorization",
* }
*
* @return [{string, string}] List of errors return in an HTTP response or [].
*/
public function getErrors()
{
return $this->errors;
}
/**
* Gets the number of times the associated task can be retried.
*
* NOTE: -1 is returned if the task can be retried indefinitely
*
* @return integer
*/
public function allowedRetries()
{
if (isset($this->retryMap[$this->code])) {
return $this->retryMap[$this->code];
}
$errors = $this->getErrors();
if (!empty($errors) && isset($errors[0]['reason']) &&
isset($this->retryMap[$errors[0]['reason']])) {
return $this->retryMap[$errors[0]['reason']];
}
return 0;
}
}

1568
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Fitness.php vendored
View File

File diff suppressed because it is too large Load Diff

453
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Freebase.php vendored
View File

@ -1,453 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Freebase (v1).
*
* <p>
* Find Freebase entities using textual queries and other constraints.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/freebase/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Freebase extends Google_Service
{
private $base_methods;
/**
* Constructs the internal representation of the Freebase service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'freebase/v1/';
$this->version = 'v1';
$this->serviceName = 'freebase';
$this->base_methods = new Google_Service_Resource(
$this,
$this->serviceName,
'',
array(
'methods' => array(
'reconcile' => array(
'path' => 'reconcile',
'httpMethod' => 'GET',
'parameters' => array(
'lang' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'confidence' => array(
'location' => 'query',
'type' => 'number',
),
'name' => array(
'location' => 'query',
'type' => 'string',
),
'kind' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'prop' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'limit' => array(
'location' => 'query',
'type' => 'integer',
),
),
),'search' => array(
'path' => 'search',
'httpMethod' => 'GET',
'parameters' => array(
'domain' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'help' => array(
'location' => 'query',
'type' => 'string',
),
'query' => array(
'location' => 'query',
'type' => 'string',
),
'scoring' => array(
'location' => 'query',
'type' => 'string',
),
'cursor' => array(
'location' => 'query',
'type' => 'integer',
),
'prefixed' => array(
'location' => 'query',
'type' => 'boolean',
),
'exact' => array(
'location' => 'query',
'type' => 'boolean',
),
'mid' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'encode' => array(
'location' => 'query',
'type' => 'string',
),
'type' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'as_of_time' => array(
'location' => 'query',
'type' => 'string',
),
'stemmed' => array(
'location' => 'query',
'type' => 'boolean',
),
'format' => array(
'location' => 'query',
'type' => 'string',
),
'spell' => array(
'location' => 'query',
'type' => 'string',
),
'with' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'lang' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'indent' => array(
'location' => 'query',
'type' => 'boolean',
),
'filter' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'callback' => array(
'location' => 'query',
'type' => 'string',
),
'without' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'limit' => array(
'location' => 'query',
'type' => 'integer',
),
'output' => array(
'location' => 'query',
'type' => 'string',
),
'mql_output' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
/**
* Reconcile entities to Freebase open data. (reconcile)
*
* @param array $optParams Optional parameters.
*
* @opt_param string lang Languages for names and values. First language is used
* for display. Default is 'en'.
* @opt_param float confidence Required confidence for a candidate to match.
* Must be between .5 and 1.0
* @opt_param string name Name of entity.
* @opt_param string kind Classifications of entity e.g. type, category, title.
* @opt_param string prop Property values for entity formatted as :
* @opt_param int limit Maximum number of candidates to return.
* @return Google_Service_Freebase_ReconcileGet
*/
public function reconcile($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->base_methods->call('reconcile', array($params), "Google_Service_Freebase_ReconcileGet");
}
/**
* Search Freebase open data. (search)
*
* @param array $optParams Optional parameters.
*
* @opt_param string domain Restrict to topics with this Freebase domain id.
* @opt_param string help The keyword to request help on.
* @opt_param string query Query term to search for.
* @opt_param string scoring Relevance scoring algorithm to use.
* @opt_param int cursor The cursor value to use for the next page of results.
* @opt_param bool prefixed Prefix match against names and aliases.
* @opt_param bool exact Query on exact name and keys only.
* @opt_param string mid A mid to use instead of a query.
* @opt_param string encode The encoding of the response. You can use this
* parameter to enable html encoding.
* @opt_param string type Restrict to topics with this Freebase type id.
* @opt_param string as_of_time A mql as_of_time value to use with mql_output
* queries.
* @opt_param bool stemmed Query on stemmed names and aliases. May not be used
* with prefixed.
* @opt_param string format Structural format of the json response.
* @opt_param string spell Request 'did you mean' suggestions
* @opt_param string with A rule to match against.
* @opt_param string lang The code of the language to run the query with.
* Default is 'en'.
* @opt_param bool indent Whether to indent the json results or not.
* @opt_param string filter A filter to apply to the query.
* @opt_param string callback JS method name for JSONP callbacks.
* @opt_param string without A rule to not match against.
* @opt_param int limit Maximum number of results to return.
* @opt_param string output An output expression to request data from matches.
* @opt_param string mql_output The MQL query to run againist the results to
* extract more data.
*/
public function search($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->base_methods->call('search', array($params));
}
}
class Google_Service_Freebase_ReconcileCandidate extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $confidence;
public $lang;
public $mid;
public $name;
protected $notableType = 'Google_Service_Freebase_ReconcileCandidateNotable';
protected $notableDataType = '';
public function setConfidence($confidence)
{
$this->confidence = $confidence;
}
public function getConfidence()
{
return $this->confidence;
}
public function setLang($lang)
{
$this->lang = $lang;
}
public function getLang()
{
return $this->lang;
}
public function setMid($mid)
{
$this->mid = $mid;
}
public function getMid()
{
return $this->mid;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setNotable(Google_Service_Freebase_ReconcileCandidateNotable $notable)
{
$this->notable = $notable;
}
public function getNotable()
{
return $this->notable;
}
}
class Google_Service_Freebase_ReconcileCandidateNotable extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $id;
public $name;
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
}
class Google_Service_Freebase_ReconcileGet extends Google_Collection
{
protected $collection_key = 'warning';
protected $internal_gapi_mappings = array(
);
protected $candidateType = 'Google_Service_Freebase_ReconcileCandidate';
protected $candidateDataType = 'array';
protected $costsType = 'Google_Service_Freebase_ReconcileGetCosts';
protected $costsDataType = '';
protected $matchType = 'Google_Service_Freebase_ReconcileCandidate';
protected $matchDataType = '';
protected $warningType = 'Google_Service_Freebase_ReconcileGetWarning';
protected $warningDataType = 'array';
public function setCandidate($candidate)
{
$this->candidate = $candidate;
}
public function getCandidate()
{
return $this->candidate;
}
public function setCosts(Google_Service_Freebase_ReconcileGetCosts $costs)
{
$this->costs = $costs;
}
public function getCosts()
{
return $this->costs;
}
public function setMatch(Google_Service_Freebase_ReconcileCandidate $match)
{
$this->match = $match;
}
public function getMatch()
{
return $this->match;
}
public function setWarning($warning)
{
$this->warning = $warning;
}
public function getWarning()
{
return $this->warning;
}
}
class Google_Service_Freebase_ReconcileGetCosts extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $hits;
public $ms;
public function setHits($hits)
{
$this->hits = $hits;
}
public function getHits()
{
return $this->hits;
}
public function setMs($ms)
{
$this->ms = $ms;
}
public function getMs()
{
return $this->ms;
}
}
class Google_Service_Freebase_ReconcileGetWarning extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $location;
public $message;
public $reason;
public function setLocation($location)
{
$this->location = $location;
}
public function getLocation()
{
return $this->location;
}
public function setMessage($message)
{
$this->message = $message;
}
public function getMessage()
{
return $this->message;
}
public function setReason($reason)
{
$this->reason = $reason;
}
public function getReason()
{
return $this->reason;
}
}

2485
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Fusiontables.php vendored
View File

File diff suppressed because it is too large Load Diff

7440
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Games.php vendored
View File

File diff suppressed because it is too large Load Diff

1068
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/GamesConfiguration.php vendored
View File

File diff suppressed because it is too large Load Diff

1404
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/GamesManagement.php vendored
View File

File diff suppressed because it is too large Load Diff

3990
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Genomics.php vendored
View File

File diff suppressed because it is too large Load Diff

2215
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Gmail.php vendored
View File

File diff suppressed because it is too large Load Diff

130
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/GroupsMigration.php vendored
View File

@ -1,130 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for GroupsMigration (v1).
*
* <p>
* Groups Migration Api.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/google-apps/groups-migration/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_GroupsMigration extends Google_Service
{
/** Manage messages in groups on your domain. */
const APPS_GROUPS_MIGRATION =
"https://www.googleapis.com/auth/apps.groups.migration";
public $archive;
/**
* Constructs the internal representation of the GroupsMigration service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'groups/v1/groups/';
$this->version = 'v1';
$this->serviceName = 'groupsmigration';
$this->archive = new Google_Service_GroupsMigration_Archive_Resource(
$this,
$this->serviceName,
'archive',
array(
'methods' => array(
'insert' => array(
'path' => '{groupId}/archive',
'httpMethod' => 'POST',
'parameters' => array(
'groupId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "archive" collection of methods.
* Typical usage is:
* <code>
* $groupsmigrationService = new Google_Service_GroupsMigration(...);
* $archive = $groupsmigrationService->archive;
* </code>
*/
class Google_Service_GroupsMigration_Archive_Resource extends Google_Service_Resource
{
/**
* Inserts a new mail into the archive of the Google group. (archive.insert)
*
* @param string $groupId The group ID
* @param array $optParams Optional parameters.
* @return Google_Service_GroupsMigration_Groups
*/
public function insert($groupId, $optParams = array())
{
$params = array('groupId' => $groupId);
$params = array_merge($params, $optParams);
return $this->call('insert', array($params), "Google_Service_GroupsMigration_Groups");
}
}
class Google_Service_GroupsMigration_Groups extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $kind;
public $responseCode;
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setResponseCode($responseCode)
{
$this->responseCode = $responseCode;
}
public function getResponseCode()
{
return $this->responseCode;
}
}

415
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Groupssettings.php vendored
View File

@ -1,415 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Groupssettings (v1).
*
* <p>
* Lets you manage permission levels and related settings of a group.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/google-apps/groups-settings/get_started" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Groupssettings extends Google_Service
{
/** View and manage the settings of a Google Apps Group. */
const APPS_GROUPS_SETTINGS =
"https://www.googleapis.com/auth/apps.groups.settings";
public $groups;
/**
* Constructs the internal representation of the Groupssettings service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'groups/v1/groups/';
$this->version = 'v1';
$this->serviceName = 'groupssettings';
$this->groups = new Google_Service_Groupssettings_Groups_Resource(
$this,
$this->serviceName,
'groups',
array(
'methods' => array(
'get' => array(
'path' => '{groupUniqueId}',
'httpMethod' => 'GET',
'parameters' => array(
'groupUniqueId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'patch' => array(
'path' => '{groupUniqueId}',
'httpMethod' => 'PATCH',
'parameters' => array(
'groupUniqueId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'update' => array(
'path' => '{groupUniqueId}',
'httpMethod' => 'PUT',
'parameters' => array(
'groupUniqueId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "groups" collection of methods.
* Typical usage is:
* <code>
* $groupssettingsService = new Google_Service_Groupssettings(...);
* $groups = $groupssettingsService->groups;
* </code>
*/
class Google_Service_Groupssettings_Groups_Resource extends Google_Service_Resource
{
/**
* Gets one resource by id. (groups.get)
*
* @param string $groupUniqueId The resource ID
* @param array $optParams Optional parameters.
* @return Google_Service_Groupssettings_Groups
*/
public function get($groupUniqueId, $optParams = array())
{
$params = array('groupUniqueId' => $groupUniqueId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Groupssettings_Groups");
}
/**
* Updates an existing resource. This method supports patch semantics.
* (groups.patch)
*
* @param string $groupUniqueId The resource ID
* @param Google_Groups $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Groupssettings_Groups
*/
public function patch($groupUniqueId, Google_Service_Groupssettings_Groups $postBody, $optParams = array())
{
$params = array('groupUniqueId' => $groupUniqueId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('patch', array($params), "Google_Service_Groupssettings_Groups");
}
/**
* Updates an existing resource. (groups.update)
*
* @param string $groupUniqueId The resource ID
* @param Google_Groups $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Groupssettings_Groups
*/
public function update($groupUniqueId, Google_Service_Groupssettings_Groups $postBody, $optParams = array())
{
$params = array('groupUniqueId' => $groupUniqueId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_Groupssettings_Groups");
}
}
class Google_Service_Groupssettings_Groups extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $allowExternalMembers;
public $allowGoogleCommunication;
public $allowWebPosting;
public $archiveOnly;
public $customReplyTo;
public $defaultMessageDenyNotificationText;
public $description;
public $email;
public $includeInGlobalAddressList;
public $isArchived;
public $kind;
public $maxMessageBytes;
public $membersCanPostAsTheGroup;
public $messageDisplayFont;
public $messageModerationLevel;
public $name;
public $primaryLanguage;
public $replyTo;
public $sendMessageDenyNotification;
public $showInGroupDirectory;
public $spamModerationLevel;
public $whoCanContactOwner;
public $whoCanInvite;
public $whoCanJoin;
public $whoCanLeaveGroup;
public $whoCanPostMessage;
public $whoCanViewGroup;
public $whoCanViewMembership;
public function setAllowExternalMembers($allowExternalMembers)
{
$this->allowExternalMembers = $allowExternalMembers;
}
public function getAllowExternalMembers()
{
return $this->allowExternalMembers;
}
public function setAllowGoogleCommunication($allowGoogleCommunication)
{
$this->allowGoogleCommunication = $allowGoogleCommunication;
}
public function getAllowGoogleCommunication()
{
return $this->allowGoogleCommunication;
}
public function setAllowWebPosting($allowWebPosting)
{
$this->allowWebPosting = $allowWebPosting;
}
public function getAllowWebPosting()
{
return $this->allowWebPosting;
}
public function setArchiveOnly($archiveOnly)
{
$this->archiveOnly = $archiveOnly;
}
public function getArchiveOnly()
{
return $this->archiveOnly;
}
public function setCustomReplyTo($customReplyTo)
{
$this->customReplyTo = $customReplyTo;
}
public function getCustomReplyTo()
{
return $this->customReplyTo;
}
public function setDefaultMessageDenyNotificationText($defaultMessageDenyNotificationText)
{
$this->defaultMessageDenyNotificationText = $defaultMessageDenyNotificationText;
}
public function getDefaultMessageDenyNotificationText()
{
return $this->defaultMessageDenyNotificationText;
}
public function setDescription($description)
{
$this->description = $description;
}
public function getDescription()
{
return $this->description;
}
public function setEmail($email)
{
$this->email = $email;
}
public function getEmail()
{
return $this->email;
}
public function setIncludeInGlobalAddressList($includeInGlobalAddressList)
{
$this->includeInGlobalAddressList = $includeInGlobalAddressList;
}
public function getIncludeInGlobalAddressList()
{
return $this->includeInGlobalAddressList;
}
public function setIsArchived($isArchived)
{
$this->isArchived = $isArchived;
}
public function getIsArchived()
{
return $this->isArchived;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setMaxMessageBytes($maxMessageBytes)
{
$this->maxMessageBytes = $maxMessageBytes;
}
public function getMaxMessageBytes()
{
return $this->maxMessageBytes;
}
public function setMembersCanPostAsTheGroup($membersCanPostAsTheGroup)
{
$this->membersCanPostAsTheGroup = $membersCanPostAsTheGroup;
}
public function getMembersCanPostAsTheGroup()
{
return $this->membersCanPostAsTheGroup;
}
public function setMessageDisplayFont($messageDisplayFont)
{
$this->messageDisplayFont = $messageDisplayFont;
}
public function getMessageDisplayFont()
{
return $this->messageDisplayFont;
}
public function setMessageModerationLevel($messageModerationLevel)
{
$this->messageModerationLevel = $messageModerationLevel;
}
public function getMessageModerationLevel()
{
return $this->messageModerationLevel;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setPrimaryLanguage($primaryLanguage)
{
$this->primaryLanguage = $primaryLanguage;
}
public function getPrimaryLanguage()
{
return $this->primaryLanguage;
}
public function setReplyTo($replyTo)
{
$this->replyTo = $replyTo;
}
public function getReplyTo()
{
return $this->replyTo;
}
public function setSendMessageDenyNotification($sendMessageDenyNotification)
{
$this->sendMessageDenyNotification = $sendMessageDenyNotification;
}
public function getSendMessageDenyNotification()
{
return $this->sendMessageDenyNotification;
}
public function setShowInGroupDirectory($showInGroupDirectory)
{
$this->showInGroupDirectory = $showInGroupDirectory;
}
public function getShowInGroupDirectory()
{
return $this->showInGroupDirectory;
}
public function setSpamModerationLevel($spamModerationLevel)
{
$this->spamModerationLevel = $spamModerationLevel;
}
public function getSpamModerationLevel()
{
return $this->spamModerationLevel;
}
public function setWhoCanContactOwner($whoCanContactOwner)
{
$this->whoCanContactOwner = $whoCanContactOwner;
}
public function getWhoCanContactOwner()
{
return $this->whoCanContactOwner;
}
public function setWhoCanInvite($whoCanInvite)
{
$this->whoCanInvite = $whoCanInvite;
}
public function getWhoCanInvite()
{
return $this->whoCanInvite;
}
public function setWhoCanJoin($whoCanJoin)
{
$this->whoCanJoin = $whoCanJoin;
}
public function getWhoCanJoin()
{
return $this->whoCanJoin;
}
public function setWhoCanLeaveGroup($whoCanLeaveGroup)
{
$this->whoCanLeaveGroup = $whoCanLeaveGroup;
}
public function getWhoCanLeaveGroup()
{
return $this->whoCanLeaveGroup;
}
public function setWhoCanPostMessage($whoCanPostMessage)
{
$this->whoCanPostMessage = $whoCanPostMessage;
}
public function getWhoCanPostMessage()
{
return $this->whoCanPostMessage;
}
public function setWhoCanViewGroup($whoCanViewGroup)
{
$this->whoCanViewGroup = $whoCanViewGroup;
}
public function getWhoCanViewGroup()
{
return $this->whoCanViewGroup;
}
public function setWhoCanViewMembership($whoCanViewMembership)
{
$this->whoCanViewMembership = $whoCanViewMembership;
}
public function getWhoCanViewMembership()
{
return $this->whoCanViewMembership;
}
}

1818
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/IdentityToolkit.php vendored
View File

File diff suppressed because it is too large Load Diff

479
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Licensing.php vendored
View File

@ -1,479 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Licensing (v1).
*
* <p>
* Licensing API to view and manage license for your domain.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/google-apps/licensing/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Licensing extends Google_Service
{
/** View and manage Google Apps licenses for your domain. */
const APPS_LICENSING =
"https://www.googleapis.com/auth/apps.licensing";
public $licenseAssignments;
/**
* Constructs the internal representation of the Licensing service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'apps/licensing/v1/product/';
$this->version = 'v1';
$this->serviceName = 'licensing';
$this->licenseAssignments = new Google_Service_Licensing_LicenseAssignments_Resource(
$this,
$this->serviceName,
'licenseAssignments',
array(
'methods' => array(
'delete' => array(
'path' => '{productId}/sku/{skuId}/user/{userId}',
'httpMethod' => 'DELETE',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'userId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'get' => array(
'path' => '{productId}/sku/{skuId}/user/{userId}',
'httpMethod' => 'GET',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'userId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'insert' => array(
'path' => '{productId}/sku/{skuId}/user',
'httpMethod' => 'POST',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'listForProduct' => array(
'path' => '{productId}/users',
'httpMethod' => 'GET',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'customerId' => array(
'location' => 'query',
'type' => 'string',
'required' => true,
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
),
),'listForProductAndSku' => array(
'path' => '{productId}/sku/{skuId}/users',
'httpMethod' => 'GET',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'customerId' => array(
'location' => 'query',
'type' => 'string',
'required' => true,
),
'pageToken' => array(
'location' => 'query',
'type' => 'string',
),
'maxResults' => array(
'location' => 'query',
'type' => 'integer',
),
),
),'patch' => array(
'path' => '{productId}/sku/{skuId}/user/{userId}',
'httpMethod' => 'PATCH',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'userId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),'update' => array(
'path' => '{productId}/sku/{skuId}/user/{userId}',
'httpMethod' => 'PUT',
'parameters' => array(
'productId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'skuId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
'userId' => array(
'location' => 'path',
'type' => 'string',
'required' => true,
),
),
),
)
)
);
}
}
/**
* The "licenseAssignments" collection of methods.
* Typical usage is:
* <code>
* $licensingService = new Google_Service_Licensing(...);
* $licenseAssignments = $licensingService->licenseAssignments;
* </code>
*/
class Google_Service_Licensing_LicenseAssignments_Resource extends Google_Service_Resource
{
/**
* Revoke License. (licenseAssignments.delete)
*
* @param string $productId Name for product
* @param string $skuId Name for sku
* @param string $userId email id or unique Id of the user
* @param array $optParams Optional parameters.
*/
public function delete($productId, $skuId, $userId, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'userId' => $userId);
$params = array_merge($params, $optParams);
return $this->call('delete', array($params));
}
/**
* Get license assignment of a particular product and sku for a user
* (licenseAssignments.get)
*
* @param string $productId Name for product
* @param string $skuId Name for sku
* @param string $userId email id or unique Id of the user
* @param array $optParams Optional parameters.
* @return Google_Service_Licensing_LicenseAssignment
*/
public function get($productId, $skuId, $userId, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'userId' => $userId);
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Licensing_LicenseAssignment");
}
/**
* Assign License. (licenseAssignments.insert)
*
* @param string $productId Name for product
* @param string $skuId Name for sku
* @param Google_LicenseAssignmentInsert $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Licensing_LicenseAssignment
*/
public function insert($productId, $skuId, Google_Service_Licensing_LicenseAssignmentInsert $postBody, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('insert', array($params), "Google_Service_Licensing_LicenseAssignment");
}
/**
* List license assignments for given product of the customer.
* (licenseAssignments.listForProduct)
*
* @param string $productId Name for product
* @param string $customerId CustomerId represents the customer for whom
* licenseassignments are queried
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken Token to fetch the next page.Optional. By default
* server will return first page
* @opt_param string maxResults Maximum number of campaigns to return at one
* time. Must be positive. Optional. Default value is 100.
* @return Google_Service_Licensing_LicenseAssignmentList
*/
public function listForProduct($productId, $customerId, $optParams = array())
{
$params = array('productId' => $productId, 'customerId' => $customerId);
$params = array_merge($params, $optParams);
return $this->call('listForProduct', array($params), "Google_Service_Licensing_LicenseAssignmentList");
}
/**
* List license assignments for given product and sku of the customer.
* (licenseAssignments.listForProductAndSku)
*
* @param string $productId Name for product
* @param string $skuId Name for sku
* @param string $customerId CustomerId represents the customer for whom
* licenseassignments are queried
* @param array $optParams Optional parameters.
*
* @opt_param string pageToken Token to fetch the next page.Optional. By default
* server will return first page
* @opt_param string maxResults Maximum number of campaigns to return at one
* time. Must be positive. Optional. Default value is 100.
* @return Google_Service_Licensing_LicenseAssignmentList
*/
public function listForProductAndSku($productId, $skuId, $customerId, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'customerId' => $customerId);
$params = array_merge($params, $optParams);
return $this->call('listForProductAndSku', array($params), "Google_Service_Licensing_LicenseAssignmentList");
}
/**
* Assign License. This method supports patch semantics.
* (licenseAssignments.patch)
*
* @param string $productId Name for product
* @param string $skuId Name for sku for which license would be revoked
* @param string $userId email id or unique Id of the user
* @param Google_LicenseAssignment $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Licensing_LicenseAssignment
*/
public function patch($productId, $skuId, $userId, Google_Service_Licensing_LicenseAssignment $postBody, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'userId' => $userId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('patch', array($params), "Google_Service_Licensing_LicenseAssignment");
}
/**
* Assign License. (licenseAssignments.update)
*
* @param string $productId Name for product
* @param string $skuId Name for sku for which license would be revoked
* @param string $userId email id or unique Id of the user
* @param Google_LicenseAssignment $postBody
* @param array $optParams Optional parameters.
* @return Google_Service_Licensing_LicenseAssignment
*/
public function update($productId, $skuId, $userId, Google_Service_Licensing_LicenseAssignment $postBody, $optParams = array())
{
$params = array('productId' => $productId, 'skuId' => $skuId, 'userId' => $userId, 'postBody' => $postBody);
$params = array_merge($params, $optParams);
return $this->call('update', array($params), "Google_Service_Licensing_LicenseAssignment");
}
}
class Google_Service_Licensing_LicenseAssignment extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $etags;
public $kind;
public $productId;
public $selfLink;
public $skuId;
public $userId;
public function setEtags($etags)
{
$this->etags = $etags;
}
public function getEtags()
{
return $this->etags;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setProductId($productId)
{
$this->productId = $productId;
}
public function getProductId()
{
return $this->productId;
}
public function setSelfLink($selfLink)
{
$this->selfLink = $selfLink;
}
public function getSelfLink()
{
return $this->selfLink;
}
public function setSkuId($skuId)
{
$this->skuId = $skuId;
}
public function getSkuId()
{
return $this->skuId;
}
public function setUserId($userId)
{
$this->userId = $userId;
}
public function getUserId()
{
return $this->userId;
}
}
class Google_Service_Licensing_LicenseAssignmentInsert extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $userId;
public function setUserId($userId)
{
$this->userId = $userId;
}
public function getUserId()
{
return $this->userId;
}
}
class Google_Service_Licensing_LicenseAssignmentList extends Google_Collection
{
protected $collection_key = 'items';
protected $internal_gapi_mappings = array(
);
public $etag;
protected $itemsType = 'Google_Service_Licensing_LicenseAssignment';
protected $itemsDataType = 'array';
public $kind;
public $nextPageToken;
public function setEtag($etag)
{
$this->etag = $etag;
}
public function getEtag()
{
return $this->etag;
}
public function setItems($items)
{
$this->items = $items;
}
public function getItems()
{
return $this->items;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setNextPageToken($nextPageToken)
{
$this->nextPageToken = $nextPageToken;
}
public function getNextPageToken()
{
return $this->nextPageToken;
}
}

453
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Logging.php vendored
View File

@ -1,453 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Logging (v2beta1).
*
* <p>
* Google Cloud Logging API lets you create logs, ingest log entries, and manage
* log sinks.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://cloud.google.com/logging/docs/" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Logging extends Google_Service
{
/**
* Constructs the internal representation of the Logging service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://logging.googleapis.com/';
$this->servicePath = '';
$this->version = 'v2beta1';
$this->serviceName = 'logging';
}
}
class Google_Service_Logging_LogLine extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $logMessage;
public $severity;
protected $sourceLocationType = 'Google_Service_Logging_SourceLocation';
protected $sourceLocationDataType = '';
public $time;
public function setLogMessage($logMessage)
{
$this->logMessage = $logMessage;
}
public function getLogMessage()
{
return $this->logMessage;
}
public function setSeverity($severity)
{
$this->severity = $severity;
}
public function getSeverity()
{
return $this->severity;
}
public function setSourceLocation(Google_Service_Logging_SourceLocation $sourceLocation)
{
$this->sourceLocation = $sourceLocation;
}
public function getSourceLocation()
{
return $this->sourceLocation;
}
public function setTime($time)
{
$this->time = $time;
}
public function getTime()
{
return $this->time;
}
}
class Google_Service_Logging_RequestLog extends Google_Collection
{
protected $collection_key = 'sourceReference';
protected $internal_gapi_mappings = array(
);
public $appEngineRelease;
public $appId;
public $cost;
public $endTime;
public $finished;
public $host;
public $httpVersion;
public $instanceId;
public $instanceIndex;
public $ip;
public $latency;
protected $lineType = 'Google_Service_Logging_LogLine';
protected $lineDataType = 'array';
public $megaCycles;
public $method;
public $moduleId;
public $nickname;
public $pendingTime;
public $referrer;
public $requestId;
public $resource;
public $responseSize;
protected $sourceReferenceType = 'Google_Service_Logging_SourceReference';
protected $sourceReferenceDataType = 'array';
public $startTime;
public $status;
public $taskName;
public $taskQueueName;
public $traceId;
public $urlMapEntry;
public $userAgent;
public $versionId;
public $wasLoadingRequest;
public function setAppEngineRelease($appEngineRelease)
{
$this->appEngineRelease = $appEngineRelease;
}
public function getAppEngineRelease()
{
return $this->appEngineRelease;
}
public function setAppId($appId)
{
$this->appId = $appId;
}
public function getAppId()
{
return $this->appId;
}
public function setCost($cost)
{
$this->cost = $cost;
}
public function getCost()
{
return $this->cost;
}
public function setEndTime($endTime)
{
$this->endTime = $endTime;
}
public function getEndTime()
{
return $this->endTime;
}
public function setFinished($finished)
{
$this->finished = $finished;
}
public function getFinished()
{
return $this->finished;
}
public function setHost($host)
{
$this->host = $host;
}
public function getHost()
{
return $this->host;
}
public function setHttpVersion($httpVersion)
{
$this->httpVersion = $httpVersion;
}
public function getHttpVersion()
{
return $this->httpVersion;
}
public function setInstanceId($instanceId)
{
$this->instanceId = $instanceId;
}
public function getInstanceId()
{
return $this->instanceId;
}
public function setInstanceIndex($instanceIndex)
{
$this->instanceIndex = $instanceIndex;
}
public function getInstanceIndex()
{
return $this->instanceIndex;
}
public function setIp($ip)
{
$this->ip = $ip;
}
public function getIp()
{
return $this->ip;
}
public function setLatency($latency)
{
$this->latency = $latency;
}
public function getLatency()
{
return $this->latency;
}
public function setLine($line)
{
$this->line = $line;
}
public function getLine()
{
return $this->line;
}
public function setMegaCycles($megaCycles)
{
$this->megaCycles = $megaCycles;
}
public function getMegaCycles()
{
return $this->megaCycles;
}
public function setMethod($method)
{
$this->method = $method;
}
public function getMethod()
{
return $this->method;
}
public function setModuleId($moduleId)
{
$this->moduleId = $moduleId;
}
public function getModuleId()
{
return $this->moduleId;
}
public function setNickname($nickname)
{
$this->nickname = $nickname;
}
public function getNickname()
{
return $this->nickname;
}
public function setPendingTime($pendingTime)
{
$this->pendingTime = $pendingTime;
}
public function getPendingTime()
{
return $this->pendingTime;
}
public function setReferrer($referrer)
{
$this->referrer = $referrer;
}
public function getReferrer()
{
return $this->referrer;
}
public function setRequestId($requestId)
{
$this->requestId = $requestId;
}
public function getRequestId()
{
return $this->requestId;
}
public function setResource($resource)
{
$this->resource = $resource;
}
public function getResource()
{
return $this->resource;
}
public function setResponseSize($responseSize)
{
$this->responseSize = $responseSize;
}
public function getResponseSize()
{
return $this->responseSize;
}
public function setSourceReference($sourceReference)
{
$this->sourceReference = $sourceReference;
}
public function getSourceReference()
{
return $this->sourceReference;
}
public function setStartTime($startTime)
{
$this->startTime = $startTime;
}
public function getStartTime()
{
return $this->startTime;
}
public function setStatus($status)
{
$this->status = $status;
}
public function getStatus()
{
return $this->status;
}
public function setTaskName($taskName)
{
$this->taskName = $taskName;
}
public function getTaskName()
{
return $this->taskName;
}
public function setTaskQueueName($taskQueueName)
{
$this->taskQueueName = $taskQueueName;
}
public function getTaskQueueName()
{
return $this->taskQueueName;
}
public function setTraceId($traceId)
{
$this->traceId = $traceId;
}
public function getTraceId()
{
return $this->traceId;
}
public function setUrlMapEntry($urlMapEntry)
{
$this->urlMapEntry = $urlMapEntry;
}
public function getUrlMapEntry()
{
return $this->urlMapEntry;
}
public function setUserAgent($userAgent)
{
$this->userAgent = $userAgent;
}
public function getUserAgent()
{
return $this->userAgent;
}
public function setVersionId($versionId)
{
$this->versionId = $versionId;
}
public function getVersionId()
{
return $this->versionId;
}
public function setWasLoadingRequest($wasLoadingRequest)
{
$this->wasLoadingRequest = $wasLoadingRequest;
}
public function getWasLoadingRequest()
{
return $this->wasLoadingRequest;
}
}
class Google_Service_Logging_SourceLocation extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $file;
public $functionName;
public $line;
public function setFile($file)
{
$this->file = $file;
}
public function getFile()
{
return $this->file;
}
public function setFunctionName($functionName)
{
$this->functionName = $functionName;
}
public function getFunctionName()
{
return $this->functionName;
}
public function setLine($line)
{
$this->line = $line;
}
public function getLine()
{
return $this->line;
}
}
class Google_Service_Logging_SourceReference extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $repository;
public $revisionId;
public function setRepository($repository)
{
$this->repository = $repository;
}
public function getRepository()
{
return $this->repository;
}
public function setRevisionId($revisionId)
{
$this->revisionId = $revisionId;
}
public function getRevisionId()
{
return $this->revisionId;
}
}

1861
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Manager.php vendored
View File

File diff suppressed because it is too large Load Diff

6421
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/MapsEngine.php vendored
View File

File diff suppressed because it is too large Load Diff

1932
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Mirror.php vendored
View File

File diff suppressed because it is too large Load Diff

503
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Oauth2.php vendored
View File

@ -1,503 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Oauth2 (v2).
*
* <p>
* Lets you access OAuth2 protocol related APIs.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/accounts/docs/OAuth2" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Oauth2 extends Google_Service
{
/** Know your basic profile info and list of people in your circles.. */
const PLUS_LOGIN =
"https://www.googleapis.com/auth/plus.login";
/** Know who you are on Google. */
const PLUS_ME =
"https://www.googleapis.com/auth/plus.me";
/** View your email address. */
const USERINFO_EMAIL =
"https://www.googleapis.com/auth/userinfo.email";
/** View your basic profile info. */
const USERINFO_PROFILE =
"https://www.googleapis.com/auth/userinfo.profile";
public $userinfo;
public $userinfo_v2_me;
private $base_methods;
/**
* Constructs the internal representation of the Oauth2 service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = '';
$this->version = 'v2';
$this->serviceName = 'oauth2';
$this->userinfo = new Google_Service_Oauth2_Userinfo_Resource(
$this,
$this->serviceName,
'userinfo',
array(
'methods' => array(
'get' => array(
'path' => 'oauth2/v2/userinfo',
'httpMethod' => 'GET',
'parameters' => array(),
),
)
)
);
$this->userinfo_v2_me = new Google_Service_Oauth2_UserinfoV2Me_Resource(
$this,
$this->serviceName,
'me',
array(
'methods' => array(
'get' => array(
'path' => 'userinfo/v2/me',
'httpMethod' => 'GET',
'parameters' => array(),
),
)
)
);
$this->base_methods = new Google_Service_Resource(
$this,
$this->serviceName,
'',
array(
'methods' => array(
'getCertForOpenIdConnect' => array(
'path' => 'oauth2/v2/certs',
'httpMethod' => 'GET',
'parameters' => array(),
),'tokeninfo' => array(
'path' => 'oauth2/v2/tokeninfo',
'httpMethod' => 'POST',
'parameters' => array(
'access_token' => array(
'location' => 'query',
'type' => 'string',
),
'id_token' => array(
'location' => 'query',
'type' => 'string',
),
'token_handle' => array(
'location' => 'query',
'type' => 'string',
),
),
),
)
)
);
}
/**
* (getCertForOpenIdConnect)
*
* @param array $optParams Optional parameters.
* @return Google_Service_Oauth2_Jwk
*/
public function getCertForOpenIdConnect($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->base_methods->call('getCertForOpenIdConnect', array($params), "Google_Service_Oauth2_Jwk");
}
/**
* (tokeninfo)
*
* @param array $optParams Optional parameters.
*
* @opt_param string access_token
* @opt_param string id_token
* @opt_param string token_handle
* @return Google_Service_Oauth2_Tokeninfo
*/
public function tokeninfo($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->base_methods->call('tokeninfo', array($params), "Google_Service_Oauth2_Tokeninfo");
}
}
/**
* The "userinfo" collection of methods.
* Typical usage is:
* <code>
* $oauth2Service = new Google_Service_Oauth2(...);
* $userinfo = $oauth2Service->userinfo;
* </code>
*/
class Google_Service_Oauth2_Userinfo_Resource extends Google_Service_Resource
{
/**
* (userinfo.get)
*
* @param array $optParams Optional parameters.
* @return Google_Service_Oauth2_Userinfoplus
*/
public function get($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Oauth2_Userinfoplus");
}
}
/**
* The "v2" collection of methods.
* Typical usage is:
* <code>
* $oauth2Service = new Google_Service_Oauth2(...);
* $v2 = $oauth2Service->v2;
* </code>
*/
class Google_Service_Oauth2_UserinfoV2_Resource extends Google_Service_Resource
{
}
/**
* The "me" collection of methods.
* Typical usage is:
* <code>
* $oauth2Service = new Google_Service_Oauth2(...);
* $me = $oauth2Service->me;
* </code>
*/
class Google_Service_Oauth2_UserinfoV2Me_Resource extends Google_Service_Resource
{
/**
* (me.get)
*
* @param array $optParams Optional parameters.
* @return Google_Service_Oauth2_Userinfoplus
*/
public function get($optParams = array())
{
$params = array();
$params = array_merge($params, $optParams);
return $this->call('get', array($params), "Google_Service_Oauth2_Userinfoplus");
}
}
class Google_Service_Oauth2_Jwk extends Google_Collection
{
protected $collection_key = 'keys';
protected $internal_gapi_mappings = array(
);
protected $keysType = 'Google_Service_Oauth2_JwkKeys';
protected $keysDataType = 'array';
public function setKeys($keys)
{
$this->keys = $keys;
}
public function getKeys()
{
return $this->keys;
}
}
class Google_Service_Oauth2_JwkKeys extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $alg;
public $e;
public $kid;
public $kty;
public $n;
public $use;
public function setAlg($alg)
{
$this->alg = $alg;
}
public function getAlg()
{
return $this->alg;
}
public function setE($e)
{
$this->e = $e;
}
public function getE()
{
return $this->e;
}
public function setKid($kid)
{
$this->kid = $kid;
}
public function getKid()
{
return $this->kid;
}
public function setKty($kty)
{
$this->kty = $kty;
}
public function getKty()
{
return $this->kty;
}
public function setN($n)
{
$this->n = $n;
}
public function getN()
{
return $this->n;
}
public function setUse($use)
{
$this->use = $use;
}
public function getUse()
{
return $this->use;
}
}
class Google_Service_Oauth2_Tokeninfo extends Google_Model
{
protected $internal_gapi_mappings = array(
"accessType" => "access_type",
"expiresIn" => "expires_in",
"issuedTo" => "issued_to",
"tokenHandle" => "token_handle",
"userId" => "user_id",
"verifiedEmail" => "verified_email",
);
public $accessType;
public $audience;
public $email;
public $expiresIn;
public $issuedTo;
public $scope;
public $tokenHandle;
public $userId;
public $verifiedEmail;
public function setAccessType($accessType)
{
$this->accessType = $accessType;
}
public function getAccessType()
{
return $this->accessType;
}
public function setAudience($audience)
{
$this->audience = $audience;
}
public function getAudience()
{
return $this->audience;
}
public function setEmail($email)
{
$this->email = $email;
}
public function getEmail()
{
return $this->email;
}
public function setExpiresIn($expiresIn)
{
$this->expiresIn = $expiresIn;
}
public function getExpiresIn()
{
return $this->expiresIn;
}
public function setIssuedTo($issuedTo)
{
$this->issuedTo = $issuedTo;
}
public function getIssuedTo()
{
return $this->issuedTo;
}
public function setScope($scope)
{
$this->scope = $scope;
}
public function getScope()
{
return $this->scope;
}
public function setTokenHandle($tokenHandle)
{
$this->tokenHandle = $tokenHandle;
}
public function getTokenHandle()
{
return $this->tokenHandle;
}
public function setUserId($userId)
{
$this->userId = $userId;
}
public function getUserId()
{
return $this->userId;
}
public function setVerifiedEmail($verifiedEmail)
{
$this->verifiedEmail = $verifiedEmail;
}
public function getVerifiedEmail()
{
return $this->verifiedEmail;
}
}
class Google_Service_Oauth2_Userinfoplus extends Google_Model
{
protected $internal_gapi_mappings = array(
"familyName" => "family_name",
"givenName" => "given_name",
"verifiedEmail" => "verified_email",
);
public $email;
public $familyName;
public $gender;
public $givenName;
public $hd;
public $id;
public $link;
public $locale;
public $name;
public $picture;
public $verifiedEmail;
public function setEmail($email)
{
$this->email = $email;
}
public function getEmail()
{
return $this->email;
}
public function setFamilyName($familyName)
{
$this->familyName = $familyName;
}
public function getFamilyName()
{
return $this->familyName;
}
public function setGender($gender)
{
$this->gender = $gender;
}
public function getGender()
{
return $this->gender;
}
public function setGivenName($givenName)
{
$this->givenName = $givenName;
}
public function getGivenName()
{
return $this->givenName;
}
public function setHd($hd)
{
$this->hd = $hd;
}
public function getHd()
{
return $this->hd;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setLink($link)
{
$this->link = $link;
}
public function getLink()
{
return $this->link;
}
public function setLocale($locale)
{
$this->locale = $locale;
}
public function getLocale()
{
return $this->locale;
}
public function setName($name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setPicture($picture)
{
$this->picture = $picture;
}
public function getPicture()
{
return $this->picture;
}
public function setVerifiedEmail($verifiedEmail)
{
$this->verifiedEmail = $verifiedEmail;
}
public function getVerifiedEmail()
{
return $this->verifiedEmail;
}
}

838
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Pagespeedonline.php vendored
View File

@ -1,838 +0,0 @@
<?php
/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
/**
* Service definition for Pagespeedonline (v2).
*
* <p>
* Lets you analyze the performance of a web page and get tailored suggestions
* to make that page faster.</p>
*
* <p>
* For more information about this service, see the API
* <a href="https://developers.google.com/speed/docs/insights/v2/getting-started" target="_blank">Documentation</a>
* </p>
*
* @author Google, Inc.
*/
class Google_Service_Pagespeedonline extends Google_Service
{
public $pagespeedapi;
/**
* Constructs the internal representation of the Pagespeedonline service.
*
* @param Google_Client $client
*/
public function __construct(Google_Client $client)
{
parent::__construct($client);
$this->rootUrl = 'https://www.googleapis.com/';
$this->servicePath = 'pagespeedonline/v2/';
$this->version = 'v2';
$this->serviceName = 'pagespeedonline';
$this->pagespeedapi = new Google_Service_Pagespeedonline_Pagespeedapi_Resource(
$this,
$this->serviceName,
'pagespeedapi',
array(
'methods' => array(
'runpagespeed' => array(
'path' => 'runPagespeed',
'httpMethod' => 'GET',
'parameters' => array(
'url' => array(
'location' => 'query',
'type' => 'string',
'required' => true,
),
'screenshot' => array(
'location' => 'query',
'type' => 'boolean',
),
'locale' => array(
'location' => 'query',
'type' => 'string',
),
'rule' => array(
'location' => 'query',
'type' => 'string',
'repeated' => true,
),
'strategy' => array(
'location' => 'query',
'type' => 'string',
),
'filter_third_party_resources' => array(
'location' => 'query',
'type' => 'boolean',
),
),
),
)
)
);
}
}
/**
* The "pagespeedapi" collection of methods.
* Typical usage is:
* <code>
* $pagespeedonlineService = new Google_Service_Pagespeedonline(...);
* $pagespeedapi = $pagespeedonlineService->pagespeedapi;
* </code>
*/
class Google_Service_Pagespeedonline_Pagespeedapi_Resource extends Google_Service_Resource
{
/**
* Runs PageSpeed analysis on the page at the specified URL, and returns
* PageSpeed scores, a list of suggestions to make that page faster, and other
* information. (pagespeedapi.runpagespeed)
*
* @param string $url The URL to fetch and analyze
* @param array $optParams Optional parameters.
*
* @opt_param bool screenshot Indicates if binary data containing a screenshot
* should be included
* @opt_param string locale The locale used to localize formatted results
* @opt_param string rule A PageSpeed rule to run; if none are given, all rules
* are run
* @opt_param string strategy The analysis strategy to use
* @opt_param bool filter_third_party_resources Indicates if third party
* resources should be filtered out before PageSpeed analysis.
* @return Google_Service_Pagespeedonline_Result
*/
public function runpagespeed($url, $optParams = array())
{
$params = array('url' => $url);
$params = array_merge($params, $optParams);
return $this->call('runpagespeed', array($params), "Google_Service_Pagespeedonline_Result");
}
}
class Google_Service_Pagespeedonline_PagespeedApiFormatStringV2 extends Google_Collection
{
protected $collection_key = 'args';
protected $internal_gapi_mappings = array(
);
protected $argsType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2Args';
protected $argsDataType = 'array';
public $format;
public function setArgs($args)
{
$this->args = $args;
}
public function getArgs()
{
return $this->args;
}
public function setFormat($format)
{
$this->format = $format;
}
public function getFormat()
{
return $this->format;
}
}
class Google_Service_Pagespeedonline_PagespeedApiFormatStringV2Args extends Google_Collection
{
protected $collection_key = 'secondary_rects';
protected $internal_gapi_mappings = array(
"secondaryRects" => "secondary_rects",
);
public $key;
protected $rectsType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2ArgsRects';
protected $rectsDataType = 'array';
protected $secondaryRectsType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2ArgsSecondaryRects';
protected $secondaryRectsDataType = 'array';
public $type;
public $value;
public function setKey($key)
{
$this->key = $key;
}
public function getKey()
{
return $this->key;
}
public function setRects($rects)
{
$this->rects = $rects;
}
public function getRects()
{
return $this->rects;
}
public function setSecondaryRects($secondaryRects)
{
$this->secondaryRects = $secondaryRects;
}
public function getSecondaryRects()
{
return $this->secondaryRects;
}
public function setType($type)
{
$this->type = $type;
}
public function getType()
{
return $this->type;
}
public function setValue($value)
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}
class Google_Service_Pagespeedonline_PagespeedApiFormatStringV2ArgsRects extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $height;
public $left;
public $top;
public $width;
public function setHeight($height)
{
$this->height = $height;
}
public function getHeight()
{
return $this->height;
}
public function setLeft($left)
{
$this->left = $left;
}
public function getLeft()
{
return $this->left;
}
public function setTop($top)
{
$this->top = $top;
}
public function getTop()
{
return $this->top;
}
public function setWidth($width)
{
$this->width = $width;
}
public function getWidth()
{
return $this->width;
}
}
class Google_Service_Pagespeedonline_PagespeedApiFormatStringV2ArgsSecondaryRects extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $height;
public $left;
public $top;
public $width;
public function setHeight($height)
{
$this->height = $height;
}
public function getHeight()
{
return $this->height;
}
public function setLeft($left)
{
$this->left = $left;
}
public function getLeft()
{
return $this->left;
}
public function setTop($top)
{
$this->top = $top;
}
public function getTop()
{
return $this->top;
}
public function setWidth($width)
{
$this->width = $width;
}
public function getWidth()
{
return $this->width;
}
}
class Google_Service_Pagespeedonline_PagespeedApiImageV2 extends Google_Model
{
protected $internal_gapi_mappings = array(
"mimeType" => "mime_type",
"pageRect" => "page_rect",
);
public $data;
public $height;
public $key;
public $mimeType;
protected $pageRectType = 'Google_Service_Pagespeedonline_PagespeedApiImageV2PageRect';
protected $pageRectDataType = '';
public $width;
public function setData($data)
{
$this->data = $data;
}
public function getData()
{
return $this->data;
}
public function setHeight($height)
{
$this->height = $height;
}
public function getHeight()
{
return $this->height;
}
public function setKey($key)
{
$this->key = $key;
}
public function getKey()
{
return $this->key;
}
public function setMimeType($mimeType)
{
$this->mimeType = $mimeType;
}
public function getMimeType()
{
return $this->mimeType;
}
public function setPageRect(Google_Service_Pagespeedonline_PagespeedApiImageV2PageRect $pageRect)
{
$this->pageRect = $pageRect;
}
public function getPageRect()
{
return $this->pageRect;
}
public function setWidth($width)
{
$this->width = $width;
}
public function getWidth()
{
return $this->width;
}
}
class Google_Service_Pagespeedonline_PagespeedApiImageV2PageRect extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $height;
public $left;
public $top;
public $width;
public function setHeight($height)
{
$this->height = $height;
}
public function getHeight()
{
return $this->height;
}
public function setLeft($left)
{
$this->left = $left;
}
public function getLeft()
{
return $this->left;
}
public function setTop($top)
{
$this->top = $top;
}
public function getTop()
{
return $this->top;
}
public function setWidth($width)
{
$this->width = $width;
}
public function getWidth()
{
return $this->width;
}
}
class Google_Service_Pagespeedonline_Result extends Google_Collection
{
protected $collection_key = 'invalidRules';
protected $internal_gapi_mappings = array(
);
protected $formattedResultsType = 'Google_Service_Pagespeedonline_ResultFormattedResults';
protected $formattedResultsDataType = '';
public $id;
public $invalidRules;
public $kind;
protected $pageStatsType = 'Google_Service_Pagespeedonline_ResultPageStats';
protected $pageStatsDataType = '';
public $responseCode;
protected $ruleGroupsType = 'Google_Service_Pagespeedonline_ResultRuleGroupsElement';
protected $ruleGroupsDataType = 'map';
protected $screenshotType = 'Google_Service_Pagespeedonline_PagespeedApiImageV2';
protected $screenshotDataType = '';
public $title;
protected $versionType = 'Google_Service_Pagespeedonline_ResultVersion';
protected $versionDataType = '';
public function setFormattedResults(Google_Service_Pagespeedonline_ResultFormattedResults $formattedResults)
{
$this->formattedResults = $formattedResults;
}
public function getFormattedResults()
{
return $this->formattedResults;
}
public function setId($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setInvalidRules($invalidRules)
{
$this->invalidRules = $invalidRules;
}
public function getInvalidRules()
{
return $this->invalidRules;
}
public function setKind($kind)
{
$this->kind = $kind;
}
public function getKind()
{
return $this->kind;
}
public function setPageStats(Google_Service_Pagespeedonline_ResultPageStats $pageStats)
{
$this->pageStats = $pageStats;
}
public function getPageStats()
{
return $this->pageStats;
}
public function setResponseCode($responseCode)
{
$this->responseCode = $responseCode;
}
public function getResponseCode()
{
return $this->responseCode;
}
public function setRuleGroups($ruleGroups)
{
$this->ruleGroups = $ruleGroups;
}
public function getRuleGroups()
{
return $this->ruleGroups;
}
public function setScreenshot(Google_Service_Pagespeedonline_PagespeedApiImageV2 $screenshot)
{
$this->screenshot = $screenshot;
}
public function getScreenshot()
{
return $this->screenshot;
}
public function setTitle($title)
{
$this->title = $title;
}
public function getTitle()
{
return $this->title;
}
public function setVersion(Google_Service_Pagespeedonline_ResultVersion $version)
{
$this->version = $version;
}
public function getVersion()
{
return $this->version;
}
}
class Google_Service_Pagespeedonline_ResultFormattedResults extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $locale;
protected $ruleResultsType = 'Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElement';
protected $ruleResultsDataType = 'map';
public function setLocale($locale)
{
$this->locale = $locale;
}
public function getLocale()
{
return $this->locale;
}
public function setRuleResults($ruleResults)
{
$this->ruleResults = $ruleResults;
}
public function getRuleResults()
{
return $this->ruleResults;
}
}
class Google_Service_Pagespeedonline_ResultFormattedResultsRuleResults extends Google_Model
{
}
class Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElement extends Google_Collection
{
protected $collection_key = 'urlBlocks';
protected $internal_gapi_mappings = array(
);
public $groups;
public $localizedRuleName;
public $ruleImpact;
protected $summaryType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2';
protected $summaryDataType = '';
protected $urlBlocksType = 'Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElementUrlBlocks';
protected $urlBlocksDataType = 'array';
public function setGroups($groups)
{
$this->groups = $groups;
}
public function getGroups()
{
return $this->groups;
}
public function setLocalizedRuleName($localizedRuleName)
{
$this->localizedRuleName = $localizedRuleName;
}
public function getLocalizedRuleName()
{
return $this->localizedRuleName;
}
public function setRuleImpact($ruleImpact)
{
$this->ruleImpact = $ruleImpact;
}
public function getRuleImpact()
{
return $this->ruleImpact;
}
public function setSummary(Google_Service_Pagespeedonline_PagespeedApiFormatStringV2 $summary)
{
$this->summary = $summary;
}
public function getSummary()
{
return $this->summary;
}
public function setUrlBlocks($urlBlocks)
{
$this->urlBlocks = $urlBlocks;
}
public function getUrlBlocks()
{
return $this->urlBlocks;
}
}
class Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElementUrlBlocks extends Google_Collection
{
protected $collection_key = 'urls';
protected $internal_gapi_mappings = array(
);
protected $headerType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2';
protected $headerDataType = '';
protected $urlsType = 'Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElementUrlBlocksUrls';
protected $urlsDataType = 'array';
public function setHeader(Google_Service_Pagespeedonline_PagespeedApiFormatStringV2 $header)
{
$this->header = $header;
}
public function getHeader()
{
return $this->header;
}
public function setUrls($urls)
{
$this->urls = $urls;
}
public function getUrls()
{
return $this->urls;
}
}
class Google_Service_Pagespeedonline_ResultFormattedResultsRuleResultsElementUrlBlocksUrls extends Google_Collection
{
protected $collection_key = 'details';
protected $internal_gapi_mappings = array(
);
protected $detailsType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2';
protected $detailsDataType = 'array';
protected $resultType = 'Google_Service_Pagespeedonline_PagespeedApiFormatStringV2';
protected $resultDataType = '';
public function setDetails($details)
{
$this->details = $details;
}
public function getDetails()
{
return $this->details;
}
public function setResult(Google_Service_Pagespeedonline_PagespeedApiFormatStringV2 $result)
{
$this->result = $result;
}
public function getResult()
{
return $this->result;
}
}
class Google_Service_Pagespeedonline_ResultPageStats extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $cssResponseBytes;
public $flashResponseBytes;
public $htmlResponseBytes;
public $imageResponseBytes;
public $javascriptResponseBytes;
public $numberCssResources;
public $numberHosts;
public $numberJsResources;
public $numberResources;
public $numberStaticResources;
public $otherResponseBytes;
public $textResponseBytes;
public $totalRequestBytes;
public function setCssResponseBytes($cssResponseBytes)
{
$this->cssResponseBytes = $cssResponseBytes;
}
public function getCssResponseBytes()
{
return $this->cssResponseBytes;
}
public function setFlashResponseBytes($flashResponseBytes)
{
$this->flashResponseBytes = $flashResponseBytes;
}
public function getFlashResponseBytes()
{
return $this->flashResponseBytes;
}
public function setHtmlResponseBytes($htmlResponseBytes)
{
$this->htmlResponseBytes = $htmlResponseBytes;
}
public function getHtmlResponseBytes()
{
return $this->htmlResponseBytes;
}
public function setImageResponseBytes($imageResponseBytes)
{
$this->imageResponseBytes = $imageResponseBytes;
}
public function getImageResponseBytes()
{
return $this->imageResponseBytes;
}
public function setJavascriptResponseBytes($javascriptResponseBytes)
{
$this->javascriptResponseBytes = $javascriptResponseBytes;
}
public function getJavascriptResponseBytes()
{
return $this->javascriptResponseBytes;
}
public function setNumberCssResources($numberCssResources)
{
$this->numberCssResources = $numberCssResources;
}
public function getNumberCssResources()
{
return $this->numberCssResources;
}
public function setNumberHosts($numberHosts)
{
$this->numberHosts = $numberHosts;
}
public function getNumberHosts()
{
return $this->numberHosts;
}
public function setNumberJsResources($numberJsResources)
{
$this->numberJsResources = $numberJsResources;
}
public function getNumberJsResources()
{
return $this->numberJsResources;
}
public function setNumberResources($numberResources)
{
$this->numberResources = $numberResources;
}
public function getNumberResources()
{
return $this->numberResources;
}
public function setNumberStaticResources($numberStaticResources)
{
$this->numberStaticResources = $numberStaticResources;
}
public function getNumberStaticResources()
{
return $this->numberStaticResources;
}
public function setOtherResponseBytes($otherResponseBytes)
{
$this->otherResponseBytes = $otherResponseBytes;
}
public function getOtherResponseBytes()
{
return $this->otherResponseBytes;
}
public function setTextResponseBytes($textResponseBytes)
{
$this->textResponseBytes = $textResponseBytes;
}
public function getTextResponseBytes()
{
return $this->textResponseBytes;
}
public function setTotalRequestBytes($totalRequestBytes)
{
$this->totalRequestBytes = $totalRequestBytes;
}
public function getTotalRequestBytes()
{
return $this->totalRequestBytes;
}
}
class Google_Service_Pagespeedonline_ResultRuleGroups extends Google_Model
{
}
class Google_Service_Pagespeedonline_ResultRuleGroupsElement extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $score;
public function setScore($score)
{
$this->score = $score;
}
public function getScore()
{
return $this->score;
}
}
class Google_Service_Pagespeedonline_ResultVersion extends Google_Model
{
protected $internal_gapi_mappings = array(
);
public $major;
public $minor;
public function setMajor($major)
{
$this->major = $major;
}
public function getMajor()
{
return $this->major;
}
public function setMinor($minor)
{
$this->minor = $minor;
}
public function getMinor()
{
return $this->minor;
}
}

1610
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Partners.php vendored
View File

File diff suppressed because it is too large Load Diff

1676
apps/files_external/3rdparty/google-api-php-client/src/Google/Service/Playmoviespartner.php vendored
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More