1
This commit is contained in:
aozhiwei
commit
3eeac83d25
203
LICENSE
Normal file
203
LICENSE
Normal file
@ -0,0 +1,203 @@
|
||||
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.
|
||||
|
||||
|
||||
461
README.md
Normal file
461
README.md
Normal file
@ -0,0 +1,461 @@
|
||||
|
||||
|
||||
# Google APIs Client Library for PHP #
|
||||
|
||||
<dl>
|
||||
<dt>Reference Docs</dt><dd><a href="https://googleapis.github.io/google-api-php-client/master/">https://googleapis.github.io/google-api-php-client/master/</a></dd>
|
||||
<dt>License</dt><dd>Apache 2.0</dd>
|
||||
</dl>
|
||||
|
||||
The Google API Client Library enables you to work with Google APIs such as Gmail, Drive or YouTube on your server.
|
||||
|
||||
These client libraries are officially supported by Google. However, the libraries are considered complete and are in maintenance mode. This means that we will address critical bugs and security issues but will not add any new features.
|
||||
|
||||
**NOTE** The actively maintained (v2) version of this client requires PHP 5.4 or above. If you require support for PHP 5.2 or 5.3, use the v1 branch.
|
||||
|
||||
## Google Cloud Platform
|
||||
|
||||
For Google Cloud Platform APIs such as Datastore, Cloud Storage or Pub/Sub, we recommend using [GoogleCloudPlatform/google-cloud-php](https://github.com/googleapis/google-cloud-php) which is under active development.
|
||||
|
||||
## Requirements ##
|
||||
* [PHP 5.4.0 or higher](https://www.php.net/)
|
||||
|
||||
## Developer Documentation ##
|
||||
|
||||
The [docs folder](docs/) provides detailed guides for using this library.
|
||||
|
||||
## Installation ##
|
||||
|
||||
You can use **Composer** or simply **Download the Release**
|
||||
|
||||
### Composer
|
||||
|
||||
The preferred method is via [composer](https://getcomposer.org/). Follow the
|
||||
[installation instructions](https://getcomposer.org/doc/00-intro.md) if you do not already have
|
||||
composer installed.
|
||||
|
||||
Once composer is installed, execute the following command in your project root to install this library:
|
||||
|
||||
```sh
|
||||
composer require google/apiclient:"^2.7"
|
||||
```
|
||||
|
||||
Finally, be sure to include the autoloader:
|
||||
|
||||
```php
|
||||
require_once '/path/to/your-project/vendor/autoload.php';
|
||||
```
|
||||
|
||||
This library relies on `google/apiclient-services`. That library provides up-to-date API wrappers for a large number of Google APIs. In order that users may make use of the latest API clients, this library does not pin to a specific version of `google/apiclient-services`. **In order to prevent the accidental installation of API wrappers with breaking changes**, it is highly recommended that you pin to the [latest version](https://github.com/googleapis/google-api-php-client-services/releases) yourself prior to using this library in production.
|
||||
|
||||
#### Cleaning up unused services
|
||||
|
||||
There are over 200 Google API services. The chances are good that you will not
|
||||
want them all. In order to avoid shipping these dependencies with your code,
|
||||
you can run the `Google\Task\Composer::cleanup` task and specify the services
|
||||
you want to keep in `composer.json`:
|
||||
|
||||
```json
|
||||
{
|
||||
"require": {
|
||||
"google/apiclient": "^2.7"
|
||||
},
|
||||
"scripts": {
|
||||
"post-update-cmd": "Google\\Task\\Composer::cleanup"
|
||||
},
|
||||
"extra": {
|
||||
"google/apiclient-services": [
|
||||
"Drive",
|
||||
"YouTube"
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
This example will remove all services other than "Drive" and "YouTube" when
|
||||
`composer update` or a fresh `composer install` is run.
|
||||
|
||||
**IMPORTANT**: If you add any services back in `composer.json`, you will need to
|
||||
remove the `vendor/google/apiclient-services` directory explicity for the
|
||||
change you made to have effect:
|
||||
|
||||
```sh
|
||||
rm -r vendor/google/apiclient-services
|
||||
composer update
|
||||
```
|
||||
|
||||
**NOTE**: This command performs an exact match on the service name, so to keep
|
||||
`YouTubeReporting` and `YouTubeAnalytics` as well, you'd need to add each of
|
||||
them explicitly:
|
||||
|
||||
```json
|
||||
{
|
||||
"extra": {
|
||||
"google/apiclient-services": [
|
||||
"Drive",
|
||||
"YouTube",
|
||||
"YouTubeAnalytics",
|
||||
"YouTubeReporting"
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Download the Release
|
||||
|
||||
If you prefer not to use composer, you can download the package in its entirety. The [Releases](https://github.com/googleapis/google-api-php-client/releases) page lists all stable versions. Download any file
|
||||
with the name `google-api-php-client-[RELEASE_NAME].zip` for a package including this library and its dependencies.
|
||||
|
||||
Uncompress the zip file you download, and include the autoloader in your project:
|
||||
|
||||
```php
|
||||
require_once '/path/to/google-api-php-client/vendor/autoload.php';
|
||||
```
|
||||
|
||||
For additional installation and setup instructions, see [the documentation](docs/).
|
||||
|
||||
## Examples ##
|
||||
See the [`examples/`](examples) directory for examples of the key client features. You can
|
||||
view them in your browser by running the php built-in web server.
|
||||
|
||||
```
|
||||
$ php -S localhost:8000 -t examples/
|
||||
```
|
||||
|
||||
And then browsing to the host and port you specified
|
||||
(in the above example, `http://localhost:8000`).
|
||||
|
||||
### Basic Example ###
|
||||
|
||||
```php
|
||||
// include your composer dependencies
|
||||
require_once 'vendor/autoload.php';
|
||||
|
||||
$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',
|
||||
'q' => 'Henry David Thoreau'
|
||||
);
|
||||
$results = $service->volumes->listVolumes($optParams);
|
||||
|
||||
foreach ($results->getItems() as $item) {
|
||||
echo $item['volumeInfo']['title'], "<br /> \n";
|
||||
}
|
||||
```
|
||||
|
||||
### Authentication with OAuth ###
|
||||
|
||||
> An example of this can be seen in [`examples/simple-file-upload.php`](examples/simple-file-upload.php).
|
||||
|
||||
1. Follow the instructions to [Create Web Application Credentials](docs/oauth-web.md#create-authorization-credentials)
|
||||
1. Download the JSON credentials
|
||||
1. Set the path to these credentials using `Google\Client::setAuthConfig`:
|
||||
|
||||
```php
|
||||
$client = new Google\Client();
|
||||
$client->setAuthConfig('/path/to/client_credentials.json');
|
||||
```
|
||||
|
||||
1. Set the scopes required for the API you are going to call
|
||||
|
||||
```php
|
||||
$client->addScope(Google_Service_Drive::DRIVE);
|
||||
```
|
||||
|
||||
1. Set your application's redirect URI
|
||||
|
||||
```php
|
||||
// Your redirect URI can be any registered URI, but in this example
|
||||
// we redirect back to this same page
|
||||
$redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
|
||||
$client->setRedirectUri($redirect_uri);
|
||||
```
|
||||
|
||||
1. In the script handling the redirect URI, exchange the authorization code for an access token:
|
||||
|
||||
```php
|
||||
if (isset($_GET['code'])) {
|
||||
$token = $client->fetchAccessTokenWithAuthCode($_GET['code']);
|
||||
}
|
||||
```
|
||||
|
||||
### Authentication with Service Accounts ###
|
||||
|
||||
> An example of this can be seen in [`examples/service-account.php`](examples/service-account.php).
|
||||
|
||||
Some APIs
|
||||
(such as the [YouTube Data API](https://developers.google.com/youtube/v3/)) do
|
||||
not support service accounts. Check with the specific API documentation if API
|
||||
calls return unexpected 401 or 403 errors.
|
||||
|
||||
1. Follow the instructions to [Create a Service Account](docs/oauth-server.md#creating-a-service-account)
|
||||
1. Download the JSON credentials
|
||||
1. Set the path to these credentials using the `GOOGLE_APPLICATION_CREDENTIALS` environment variable:
|
||||
|
||||
```php
|
||||
putenv('GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json');
|
||||
```
|
||||
|
||||
1. Tell the Google client to use your service account credentials to authenticate:
|
||||
|
||||
```php
|
||||
$client = new Google\Client();
|
||||
$client->useApplicationDefaultCredentials();
|
||||
```
|
||||
|
||||
1. Set the scopes required for the API you are going to call
|
||||
|
||||
```php
|
||||
$client->addScope(Google_Service_Drive::DRIVE);
|
||||
```
|
||||
|
||||
1. If you have delegated domain-wide access to the service account and you want to impersonate a user account, specify the email address of the user account using the method setSubject:
|
||||
|
||||
```php
|
||||
$client->setSubject($user_to_impersonate);
|
||||
```
|
||||
|
||||
### Making Requests ###
|
||||
|
||||
The classes used to call the API in [google-api-php-client-services](https://github.com/googleapis/google-api-php-client-services) are autogenerated. They map directly to the JSON requests and responses found in the [APIs Explorer](https://developers.google.com/apis-explorer/#p/).
|
||||
|
||||
A JSON request to the [Datastore API](https://developers.google.com/apis-explorer/#p/datastore/v1beta3/datastore.projects.runQuery) would look like this:
|
||||
|
||||
```json
|
||||
POST https://datastore.googleapis.com/v1beta3/projects/YOUR_PROJECT_ID:runQuery?key=YOUR_API_KEY
|
||||
|
||||
{
|
||||
"query": {
|
||||
"kind": [{
|
||||
"name": "Book"
|
||||
}],
|
||||
"order": [{
|
||||
"property": {
|
||||
"name": "title"
|
||||
},
|
||||
"direction": "descending"
|
||||
}],
|
||||
"limit": 10
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Using this library, the same call would look something like this:
|
||||
|
||||
```php
|
||||
// create the datastore service class
|
||||
$datastore = new Google_Service_Datastore($client);
|
||||
|
||||
// build the query - this maps directly to the JSON
|
||||
$query = new Google_Service_Datastore_Query([
|
||||
'kind' => [
|
||||
[
|
||||
'name' => 'Book',
|
||||
],
|
||||
],
|
||||
'order' => [
|
||||
'property' => [
|
||||
'name' => 'title',
|
||||
],
|
||||
'direction' => 'descending',
|
||||
],
|
||||
'limit' => 10,
|
||||
]);
|
||||
|
||||
// build the request and response
|
||||
$request = new Google_Service_Datastore_RunQueryRequest(['query' => $query]);
|
||||
$response = $datastore->projects->runQuery('YOUR_DATASET_ID', $request);
|
||||
```
|
||||
|
||||
However, as each property of the JSON API has a corresponding generated class, the above code could also be written like this:
|
||||
|
||||
```php
|
||||
// create the datastore service class
|
||||
$datastore = new Google_Service_Datastore($client);
|
||||
|
||||
// build the query
|
||||
$request = new Google_Service_Datastore_RunQueryRequest();
|
||||
$query = new Google_Service_Datastore_Query();
|
||||
// - set the order
|
||||
$order = new Google_Service_Datastore_PropertyOrder();
|
||||
$order->setDirection('descending');
|
||||
$property = new Google_Service_Datastore_PropertyReference();
|
||||
$property->setName('title');
|
||||
$order->setProperty($property);
|
||||
$query->setOrder([$order]);
|
||||
// - set the kinds
|
||||
$kind = new Google_Service_Datastore_KindExpression();
|
||||
$kind->setName('Book');
|
||||
$query->setKinds([$kind]);
|
||||
// - set the limit
|
||||
$query->setLimit(10);
|
||||
|
||||
// add the query to the request and make the request
|
||||
$request->setQuery($query);
|
||||
$response = $datastore->projects->runQuery('YOUR_DATASET_ID', $request);
|
||||
```
|
||||
|
||||
The method used is a matter of preference, but *it will be very difficult to use this library without first understanding the JSON syntax for the API*, so it is recommended to look at the [APIs Explorer](https://developers.google.com/apis-explorer/#p/) before using any of the services here.
|
||||
|
||||
### Making HTTP Requests Directly ###
|
||||
|
||||
If Google Authentication is desired for external applications, or a Google API is not available yet in this library, HTTP requests can be made directly.
|
||||
|
||||
If you are installing this client only to authenticate your own HTTP client requests, you should use [`google/auth`](https://github.com/googleapis/google-auth-library-php#call-the-apis) instead.
|
||||
|
||||
The `authorize` method returns an authorized [Guzzle Client](http://docs.guzzlephp.org/), so any request made using the client will contain the corresponding authorization.
|
||||
|
||||
```php
|
||||
// create the Google client
|
||||
$client = new Google\Client();
|
||||
|
||||
/**
|
||||
* Set your method for authentication. Depending on the API, This could be
|
||||
* directly with an access token, API key, or (recommended) using
|
||||
* Application Default Credentials.
|
||||
*/
|
||||
$client->useApplicationDefaultCredentials();
|
||||
$client->addScope(Google_Service_Plus::PLUS_ME);
|
||||
|
||||
// returns a Guzzle HTTP Client
|
||||
$httpClient = $client->authorize();
|
||||
|
||||
// make an HTTP request
|
||||
$response = $httpClient->get('https://www.googleapis.com/plus/v1/people/me');
|
||||
```
|
||||
|
||||
### Caching ###
|
||||
|
||||
It is recommended to use another caching library to improve performance. This can be done by passing a [PSR-6](https://www.php-fig.org/psr/psr-6/) compatible library to the client:
|
||||
|
||||
```php
|
||||
use League\Flysystem\Adapter\Local;
|
||||
use League\Flysystem\Filesystem;
|
||||
use Cache\Adapter\Filesystem\FilesystemCachePool;
|
||||
|
||||
$filesystemAdapter = new Local(__DIR__.'/');
|
||||
$filesystem = new Filesystem($filesystemAdapter);
|
||||
|
||||
$cache = new FilesystemCachePool($filesystem);
|
||||
$client->setCache($cache);
|
||||
```
|
||||
|
||||
In this example we use [PHP Cache](http://www.php-cache.com/). Add this to your project with composer:
|
||||
|
||||
```
|
||||
composer require cache/filesystem-adapter
|
||||
```
|
||||
|
||||
### Updating Tokens ###
|
||||
|
||||
When using [Refresh Tokens](https://developers.google.com/identity/protocols/OAuth2InstalledApp#offline) or [Service Account Credentials](https://developers.google.com/identity/protocols/OAuth2ServiceAccount#overview), it may be useful to perform some action when a new access token is granted. To do this, pass a callable to the `setTokenCallback` method on the client:
|
||||
|
||||
```php
|
||||
$logger = new Monolog\Logger();
|
||||
$tokenCallback = function ($cacheKey, $accessToken) use ($logger) {
|
||||
$logger->debug(sprintf('new access token received at cache key %s', $cacheKey));
|
||||
};
|
||||
$client->setTokenCallback($tokenCallback);
|
||||
```
|
||||
|
||||
### Debugging Your HTTP Request using Charles ###
|
||||
|
||||
It is often very useful to debug your API calls by viewing the raw HTTP request. This library supports the use of [Charles Web Proxy](https://www.charlesproxy.com/documentation/getting-started/). Download and run Charles, and then capture all HTTP traffic through Charles with the following code:
|
||||
|
||||
```php
|
||||
// FOR DEBUGGING ONLY
|
||||
$httpClient = new GuzzleHttp\Client([
|
||||
'proxy' => 'localhost:8888', // by default, Charles runs on localhost port 8888
|
||||
'verify' => false, // otherwise HTTPS requests will fail.
|
||||
]);
|
||||
|
||||
$client = new Google\Client();
|
||||
$client->setHttpClient($httpClient);
|
||||
```
|
||||
|
||||
Now all calls made by this library will appear in the Charles UI.
|
||||
|
||||
One additional step is required in Charles to view SSL requests. Go to **Charles > Proxy > SSL Proxying Settings** and add the domain you'd like captured. In the case of the Google APIs, this is usually `*.googleapis.com`.
|
||||
|
||||
### Controlling HTTP Client Configuration Directly
|
||||
|
||||
Google API Client uses [Guzzle](http://docs.guzzlephp.org/) as its default HTTP client. That means that you can control your HTTP requests in the same manner you would for any application using Guzzle.
|
||||
|
||||
Let's say, for instance, we wished to apply a referrer to each request.
|
||||
|
||||
```php
|
||||
use GuzzleHttp\Client;
|
||||
|
||||
$httpClient = new Client([
|
||||
'headers' => [
|
||||
'referer' => 'mysite.com'
|
||||
]
|
||||
]);
|
||||
|
||||
$client = new Google\Client();
|
||||
$client->setHttpClient($httpClient);
|
||||
```
|
||||
|
||||
Other Guzzle features such as [Handlers and Middleware](http://docs.guzzlephp.org/en/stable/handlers-and-middleware.html) offer even more control.
|
||||
|
||||
### Service Specific Examples ###
|
||||
|
||||
YouTube: https://github.com/youtube/api-samples/tree/master/php
|
||||
|
||||
## How Do I Contribute? ##
|
||||
|
||||
Please see the [contributing](.github/CONTRIBUTING.md) page for more information. In particular, we love pull requests - but please make sure to sign the contributor license agreement.
|
||||
|
||||
## 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: https://stackoverflow.com/questions/tagged/google-api-php-client
|
||||
|
||||
If there is a specific bug with the library, please [file an issue](https://github.com/googleapis/google-api-php-client/issues) in the GitHub issues tracker, including an 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.
|
||||
|
||||
### 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 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 uninitialized 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
|
||||
```
|
||||
47
composer.json
Normal file
47
composer.json
Normal file
@ -0,0 +1,47 @@
|
||||
{
|
||||
"name": "google/apiclient",
|
||||
"type": "library",
|
||||
"description": "Client library for Google APIs",
|
||||
"keywords": ["google"],
|
||||
"homepage": "http://developers.google.com/api-client-library/php",
|
||||
"license": "Apache-2.0",
|
||||
"require": {
|
||||
"php": ">=5.4",
|
||||
"google/auth": "^1.10",
|
||||
"google/apiclient-services": "~0.13",
|
||||
"firebase/php-jwt": "~2.0||~3.0||~4.0||~5.0",
|
||||
"monolog/monolog": "^1.17|^2.0",
|
||||
"phpseclib/phpseclib": "~0.3.10||~2.0",
|
||||
"guzzlehttp/guzzle": "~5.3.1||~6.0||~7.0",
|
||||
"guzzlehttp/psr7": "^1.2"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^4.8.36|^5.0",
|
||||
"squizlabs/php_codesniffer": "~2.3",
|
||||
"symfony/dom-crawler": "~2.1",
|
||||
"symfony/css-selector": "~2.1",
|
||||
"cache/filesystem-adapter": "^0.3.2",
|
||||
"phpcompatibility/php-compatibility": "^9.2",
|
||||
"dealerdirect/phpcodesniffer-composer-installer": "^0.7",
|
||||
"composer/composer": "^1.10"
|
||||
},
|
||||
"suggest": {
|
||||
"cache/filesystem-adapter": "For caching certs and tokens (using Google\\Client::setCache)"
|
||||
},
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
"Google\\": "src/"
|
||||
},
|
||||
"files": [
|
||||
"src/aliases.php"
|
||||
],
|
||||
"classmap": [
|
||||
"src/aliases.php"
|
||||
]
|
||||
},
|
||||
"extra": {
|
||||
"branch-alias": {
|
||||
"dev-master": "2.x-dev"
|
||||
}
|
||||
}
|
||||
}
|
||||
81
src/AccessToken/Revoke.php
Normal file
81
src/AccessToken/Revoke.php
Normal file
@ -0,0 +1,81 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\AccessToken;
|
||||
|
||||
use Google\Auth\HttpHandler\HttpHandlerFactory;
|
||||
use Google\Client;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use GuzzleHttp\Psr7;
|
||||
use GuzzleHttp\Psr7\Request;
|
||||
|
||||
/**
|
||||
* Wrapper around Google Access Tokens which provides convenience functions
|
||||
*
|
||||
*/
|
||||
class Revoke
|
||||
{
|
||||
/**
|
||||
* @var ClientInterface The http client
|
||||
*/
|
||||
private $http;
|
||||
|
||||
/**
|
||||
* Instantiates the class, but does not initiate the login flow, leaving it
|
||||
* to the discretion of the caller.
|
||||
*/
|
||||
public function __construct(ClientInterface $http = null)
|
||||
{
|
||||
$this->http = $http;
|
||||
}
|
||||
|
||||
/**
|
||||
* Revoke an OAuth2 access token or refresh token. This method will revoke the current access
|
||||
* token, if a token isn't provided.
|
||||
*
|
||||
* @param string|array $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)
|
||||
{
|
||||
if (is_array($token)) {
|
||||
if (isset($token['refresh_token'])) {
|
||||
$token = $token['refresh_token'];
|
||||
} else {
|
||||
$token = $token['access_token'];
|
||||
}
|
||||
}
|
||||
|
||||
$body = Psr7\stream_for(http_build_query(array('token' => $token)));
|
||||
$request = new Request(
|
||||
'POST',
|
||||
Client::OAUTH2_REVOKE_URI,
|
||||
[
|
||||
'Cache-Control' => 'no-store',
|
||||
'Content-Type' => 'application/x-www-form-urlencoded',
|
||||
],
|
||||
$body
|
||||
);
|
||||
|
||||
$httpHandler = HttpHandlerFactory::build($this->http);
|
||||
|
||||
$response = $httpHandler($request);
|
||||
|
||||
return $response->getStatusCode() == 200;
|
||||
}
|
||||
}
|
||||
282
src/AccessToken/Verify.php
Normal file
282
src/AccessToken/Verify.php
Normal file
@ -0,0 +1,282 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\AccessToken;
|
||||
|
||||
use Firebase\JWT\ExpiredException as ExpiredExceptionV3;
|
||||
use Firebase\JWT\SignatureInvalidException;
|
||||
use GuzzleHttp\Client;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use Psr\Cache\CacheItemPoolInterface;
|
||||
use Google\Auth\Cache\MemoryCacheItemPool;
|
||||
use Google\Exception as GoogleException;
|
||||
use Stash\Driver\FileSystem;
|
||||
use Stash\Pool;
|
||||
use DateTime;
|
||||
use DomainException;
|
||||
use Exception;
|
||||
use ExpiredException; // Firebase v2
|
||||
use LogicException;
|
||||
|
||||
/**
|
||||
* Wrapper around Google Access Tokens which provides convenience functions
|
||||
*
|
||||
*/
|
||||
class Verify
|
||||
{
|
||||
const FEDERATED_SIGNON_CERT_URL = 'https://www.googleapis.com/oauth2/v3/certs';
|
||||
const OAUTH2_ISSUER = 'accounts.google.com';
|
||||
const OAUTH2_ISSUER_HTTPS = 'https://accounts.google.com';
|
||||
|
||||
/**
|
||||
* @var ClientInterface The http client
|
||||
*/
|
||||
private $http;
|
||||
|
||||
/**
|
||||
* @var CacheItemPoolInterface cache class
|
||||
*/
|
||||
private $cache;
|
||||
|
||||
/**
|
||||
* Instantiates the class, but does not initiate the login flow, leaving it
|
||||
* to the discretion of the caller.
|
||||
*/
|
||||
public function __construct(
|
||||
ClientInterface $http = null,
|
||||
CacheItemPoolInterface $cache = null,
|
||||
$jwt = null
|
||||
) {
|
||||
if (null === $http) {
|
||||
$http = new Client();
|
||||
}
|
||||
|
||||
if (null === $cache) {
|
||||
$cache = new MemoryCacheItemPool;
|
||||
}
|
||||
|
||||
$this->http = $http;
|
||||
$this->cache = $cache;
|
||||
$this->jwt = $jwt ?: $this->getJwtService();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 string $idToken the ID token in JWT format
|
||||
* @param string $audience Optional. The audience to verify against JWt "aud"
|
||||
* @return array the token payload, if successful
|
||||
*/
|
||||
public function verifyIdToken($idToken, $audience = null)
|
||||
{
|
||||
if (empty($idToken)) {
|
||||
throw new LogicException('id_token cannot be null');
|
||||
}
|
||||
|
||||
// set phpseclib constants if applicable
|
||||
$this->setPhpsecConstants();
|
||||
|
||||
// Check signature
|
||||
$certs = $this->getFederatedSignOnCerts();
|
||||
foreach ($certs as $cert) {
|
||||
$bigIntClass = $this->getBigIntClass();
|
||||
$rsaClass = $this->getRsaClass();
|
||||
$modulus = new $bigIntClass($this->jwt->urlsafeB64Decode($cert['n']), 256);
|
||||
$exponent = new $bigIntClass($this->jwt->urlsafeB64Decode($cert['e']), 256);
|
||||
|
||||
$rsa = new $rsaClass();
|
||||
$rsa->loadKey(array('n' => $modulus, 'e' => $exponent));
|
||||
|
||||
try {
|
||||
$payload = $this->jwt->decode(
|
||||
$idToken,
|
||||
$rsa->getPublicKey(),
|
||||
array('RS256')
|
||||
);
|
||||
|
||||
if (property_exists($payload, 'aud')) {
|
||||
if ($audience && $payload->aud != $audience) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// support HTTP and HTTPS issuers
|
||||
// @see https://developers.google.com/identity/sign-in/web/backend-auth
|
||||
$issuers = array(self::OAUTH2_ISSUER, self::OAUTH2_ISSUER_HTTPS);
|
||||
if (!isset($payload->iss) || !in_array($payload->iss, $issuers)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return (array) $payload;
|
||||
} catch (ExpiredException $e) {
|
||||
return false;
|
||||
} catch (ExpiredExceptionV3 $e) {
|
||||
return false;
|
||||
} catch (SignatureInvalidException $e) {
|
||||
// continue
|
||||
} catch (DomainException $e) {
|
||||
// continue
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private function getCache()
|
||||
{
|
||||
return $this->cache;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve and cache a certificates file.
|
||||
*
|
||||
* @param $url string location
|
||||
* @throws \Google\Exception
|
||||
* @return array certificates
|
||||
*/
|
||||
private function retrieveCertsFromLocation($url)
|
||||
{
|
||||
// If we're retrieving a local file, just grab it.
|
||||
if (0 !== strpos($url, 'http')) {
|
||||
if (!$file = file_get_contents($url)) {
|
||||
throw new GoogleException(
|
||||
"Failed to retrieve verification certificates: '" .
|
||||
$url . "'."
|
||||
);
|
||||
}
|
||||
|
||||
return json_decode($file, true);
|
||||
}
|
||||
|
||||
$response = $this->http->get($url);
|
||||
|
||||
if ($response->getStatusCode() == 200) {
|
||||
return json_decode((string) $response->getBody(), true);
|
||||
}
|
||||
throw new GoogleException(
|
||||
sprintf(
|
||||
'Failed to retrieve verification certificates: "%s".',
|
||||
$response->getBody()->getContents()
|
||||
),
|
||||
$response->getStatusCode()
|
||||
);
|
||||
}
|
||||
|
||||
// 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()
|
||||
{
|
||||
$certs = null;
|
||||
if ($cache = $this->getCache()) {
|
||||
$cacheItem = $cache->getItem('federated_signon_certs_v3');
|
||||
$certs = $cacheItem->get();
|
||||
}
|
||||
|
||||
|
||||
if (!$certs) {
|
||||
$certs = $this->retrieveCertsFromLocation(
|
||||
self::FEDERATED_SIGNON_CERT_URL
|
||||
);
|
||||
|
||||
if ($cache) {
|
||||
$cacheItem->expiresAt(new DateTime('+1 hour'));
|
||||
$cacheItem->set($certs);
|
||||
$cache->save($cacheItem);
|
||||
}
|
||||
}
|
||||
|
||||
if (!isset($certs['keys'])) {
|
||||
throw new InvalidArgumentException(
|
||||
'federated sign-on certs expects "keys" to be set'
|
||||
);
|
||||
}
|
||||
|
||||
return $certs['keys'];
|
||||
}
|
||||
|
||||
private function getJwtService()
|
||||
{
|
||||
$jwtClass = 'JWT';
|
||||
if (class_exists('\Firebase\JWT\JWT')) {
|
||||
$jwtClass = 'Firebase\JWT\JWT';
|
||||
}
|
||||
|
||||
if (property_exists($jwtClass, 'leeway') && $jwtClass::$leeway < 1) {
|
||||
// Ensures JWT leeway is at least 1
|
||||
// @see https://github.com/google/google-api-php-client/issues/827
|
||||
$jwtClass::$leeway = 1;
|
||||
}
|
||||
|
||||
return new $jwtClass;
|
||||
}
|
||||
|
||||
private function getRsaClass()
|
||||
{
|
||||
if (class_exists('phpseclib\Crypt\RSA')) {
|
||||
return 'phpseclib\Crypt\RSA';
|
||||
}
|
||||
|
||||
return 'Crypt_RSA';
|
||||
}
|
||||
|
||||
private function getBigIntClass()
|
||||
{
|
||||
if (class_exists('phpseclib\Math\BigInteger')) {
|
||||
return 'phpseclib\Math\BigInteger';
|
||||
}
|
||||
|
||||
return 'Math_BigInteger';
|
||||
}
|
||||
|
||||
private function getOpenSslConstant()
|
||||
{
|
||||
if (class_exists('phpseclib\Crypt\RSA')) {
|
||||
return 'phpseclib\Crypt\RSA::MODE_OPENSSL';
|
||||
}
|
||||
|
||||
if (class_exists('Crypt_RSA')) {
|
||||
return 'CRYPT_RSA_MODE_OPENSSL';
|
||||
}
|
||||
|
||||
throw new Exception('Cannot find RSA class');
|
||||
}
|
||||
|
||||
/**
|
||||
* phpseclib calls "phpinfo" by default, which requires special
|
||||
* whitelisting in the AppEngine VM environment. This function
|
||||
* sets constants to bypass the need for phpseclib to check phpinfo
|
||||
*
|
||||
* @see phpseclib/Math/BigInteger
|
||||
* @see https://github.com/GoogleCloudPlatform/getting-started-php/issues/85
|
||||
*/
|
||||
private function setPhpsecConstants()
|
||||
{
|
||||
if (filter_var(getenv('GAE_VM'), FILTER_VALIDATE_BOOLEAN)) {
|
||||
if (!defined('MATH_BIGINTEGER_OPENSSL_ENABLED')) {
|
||||
define('MATH_BIGINTEGER_OPENSSL_ENABLED', true);
|
||||
}
|
||||
if (!defined('CRYPT_RSA_MODE')) {
|
||||
define('CRYPT_RSA_MODE', constant($this->getOpenSslConstant()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
52
src/AuthHandler/AuthHandlerFactory.php
Normal file
52
src/AuthHandler/AuthHandlerFactory.php
Normal file
@ -0,0 +1,52 @@
|
||||
<?php
|
||||
/**
|
||||
* Copyright 2015 Google Inc. All Rights Reserved.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
namespace Google\AuthHandler;
|
||||
|
||||
use GuzzleHttp\Client;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use Exception;
|
||||
|
||||
class AuthHandlerFactory
|
||||
{
|
||||
/**
|
||||
* Builds out a default http handler for the installed version of guzzle.
|
||||
*
|
||||
* @return Guzzle5AuthHandler|Guzzle6AuthHandler|Guzzle7AuthHandler
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function build($cache = null, array $cacheConfig = [])
|
||||
{
|
||||
$guzzleVersion = null;
|
||||
if (defined('\GuzzleHttp\ClientInterface::MAJOR_VERSION')) {
|
||||
$guzzleVersion = ClientInterface::MAJOR_VERSION;
|
||||
} elseif (defined('\GuzzleHttp\ClientInterface::VERSION')) {
|
||||
$guzzleVersion = (int) substr(ClientInterface::VERSION, 0, 1);
|
||||
}
|
||||
|
||||
switch ($guzzleVersion) {
|
||||
case 5:
|
||||
return new Guzzle5AuthHandler($cache, $cacheConfig);
|
||||
case 6:
|
||||
return new Guzzle6AuthHandler($cache, $cacheConfig);
|
||||
case 7:
|
||||
return new Guzzle7AuthHandler($cache, $cacheConfig);
|
||||
default:
|
||||
throw new Exception('Version not supported');
|
||||
}
|
||||
}
|
||||
}
|
||||
110
src/AuthHandler/Guzzle5AuthHandler.php
Normal file
110
src/AuthHandler/Guzzle5AuthHandler.php
Normal file
@ -0,0 +1,110 @@
|
||||
<?php
|
||||
|
||||
namespace Google\AuthHandler;
|
||||
|
||||
use Google\Auth\CredentialsLoader;
|
||||
use Google\Auth\HttpHandler\HttpHandlerFactory;
|
||||
use Google\Auth\FetchAuthTokenCache;
|
||||
use Google\Auth\Subscriber\AuthTokenSubscriber;
|
||||
use Google\Auth\Subscriber\ScopedAccessTokenSubscriber;
|
||||
use Google\Auth\Subscriber\SimpleSubscriber;
|
||||
use GuzzleHttp\Client;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use Psr\Cache\CacheItemPoolInterface;
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
class Guzzle5AuthHandler
|
||||
{
|
||||
protected $cache;
|
||||
protected $cacheConfig;
|
||||
|
||||
public function __construct(CacheItemPoolInterface $cache = null, array $cacheConfig = [])
|
||||
{
|
||||
$this->cache = $cache;
|
||||
$this->cacheConfig = $cacheConfig;
|
||||
}
|
||||
|
||||
public function attachCredentials(
|
||||
ClientInterface $http,
|
||||
CredentialsLoader $credentials,
|
||||
callable $tokenCallback = null
|
||||
) {
|
||||
// use the provided cache
|
||||
if ($this->cache) {
|
||||
$credentials = new FetchAuthTokenCache(
|
||||
$credentials,
|
||||
$this->cacheConfig,
|
||||
$this->cache
|
||||
);
|
||||
}
|
||||
|
||||
return $this->attachCredentialsCache($http, $credentials, $tokenCallback);
|
||||
}
|
||||
|
||||
public function attachCredentialsCache(
|
||||
ClientInterface $http,
|
||||
FetchAuthTokenCache $credentials,
|
||||
callable $tokenCallback = null
|
||||
) {
|
||||
// if we end up needing to make an HTTP request to retrieve credentials, we
|
||||
// can use our existing one, but we need to throw exceptions so the error
|
||||
// bubbles up.
|
||||
$authHttp = $this->createAuthHttp($http);
|
||||
$authHttpHandler = HttpHandlerFactory::build($authHttp);
|
||||
$subscriber = new AuthTokenSubscriber(
|
||||
$credentials,
|
||||
$authHttpHandler,
|
||||
$tokenCallback
|
||||
);
|
||||
|
||||
$http->setDefaultOption('auth', 'google_auth');
|
||||
$http->getEmitter()->attach($subscriber);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
public function attachToken(ClientInterface $http, array $token, array $scopes)
|
||||
{
|
||||
$tokenFunc = function ($scopes) use ($token) {
|
||||
return $token['access_token'];
|
||||
};
|
||||
|
||||
$subscriber = new ScopedAccessTokenSubscriber(
|
||||
$tokenFunc,
|
||||
$scopes,
|
||||
$this->cacheConfig,
|
||||
$this->cache
|
||||
);
|
||||
|
||||
$http->setDefaultOption('auth', 'scoped');
|
||||
$http->getEmitter()->attach($subscriber);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
public function attachKey(ClientInterface $http, $key)
|
||||
{
|
||||
$subscriber = new SimpleSubscriber(['key' => $key]);
|
||||
|
||||
$http->setDefaultOption('auth', 'simple');
|
||||
$http->getEmitter()->attach($subscriber);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
private function createAuthHttp(ClientInterface $http)
|
||||
{
|
||||
return new Client(
|
||||
[
|
||||
'base_url' => $http->getBaseUrl(),
|
||||
'defaults' => [
|
||||
'exceptions' => true,
|
||||
'verify' => $http->getDefaultOption('verify'),
|
||||
'proxy' => $http->getDefaultOption('proxy'),
|
||||
]
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
117
src/AuthHandler/Guzzle6AuthHandler.php
Normal file
117
src/AuthHandler/Guzzle6AuthHandler.php
Normal file
@ -0,0 +1,117 @@
|
||||
<?php
|
||||
|
||||
namespace Google\AuthHandler;
|
||||
|
||||
use Google\Auth\CredentialsLoader;
|
||||
use Google\Auth\HttpHandler\HttpHandlerFactory;
|
||||
use Google\Auth\FetchAuthTokenCache;
|
||||
use Google\Auth\Middleware\AuthTokenMiddleware;
|
||||
use Google\Auth\Middleware\ScopedAccessTokenMiddleware;
|
||||
use Google\Auth\Middleware\SimpleMiddleware;
|
||||
use GuzzleHttp\Client;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use Psr\Cache\CacheItemPoolInterface;
|
||||
|
||||
/**
|
||||
* This supports Guzzle 6
|
||||
*/
|
||||
class Guzzle6AuthHandler
|
||||
{
|
||||
protected $cache;
|
||||
protected $cacheConfig;
|
||||
|
||||
public function __construct(CacheItemPoolInterface $cache = null, array $cacheConfig = [])
|
||||
{
|
||||
$this->cache = $cache;
|
||||
$this->cacheConfig = $cacheConfig;
|
||||
}
|
||||
|
||||
public function attachCredentials(
|
||||
ClientInterface $http,
|
||||
CredentialsLoader $credentials,
|
||||
callable $tokenCallback = null
|
||||
) {
|
||||
// use the provided cache
|
||||
if ($this->cache) {
|
||||
$credentials = new FetchAuthTokenCache(
|
||||
$credentials,
|
||||
$this->cacheConfig,
|
||||
$this->cache
|
||||
);
|
||||
}
|
||||
|
||||
return $this->attachCredentialsCache($http, $credentials, $tokenCallback);
|
||||
}
|
||||
|
||||
public function attachCredentialsCache(
|
||||
ClientInterface $http,
|
||||
FetchAuthTokenCache $credentials,
|
||||
callable $tokenCallback = null
|
||||
) {
|
||||
// if we end up needing to make an HTTP request to retrieve credentials, we
|
||||
// can use our existing one, but we need to throw exceptions so the error
|
||||
// bubbles up.
|
||||
$authHttp = $this->createAuthHttp($http);
|
||||
$authHttpHandler = HttpHandlerFactory::build($authHttp);
|
||||
$middleware = new AuthTokenMiddleware(
|
||||
$credentials,
|
||||
$authHttpHandler,
|
||||
$tokenCallback
|
||||
);
|
||||
|
||||
$config = $http->getConfig();
|
||||
$config['handler']->remove('google_auth');
|
||||
$config['handler']->push($middleware, 'google_auth');
|
||||
$config['auth'] = 'google_auth';
|
||||
$http = new Client($config);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
public function attachToken(ClientInterface $http, array $token, array $scopes)
|
||||
{
|
||||
$tokenFunc = function ($scopes) use ($token) {
|
||||
return $token['access_token'];
|
||||
};
|
||||
|
||||
$middleware = new ScopedAccessTokenMiddleware(
|
||||
$tokenFunc,
|
||||
$scopes,
|
||||
$this->cacheConfig,
|
||||
$this->cache
|
||||
);
|
||||
|
||||
$config = $http->getConfig();
|
||||
$config['handler']->remove('google_auth');
|
||||
$config['handler']->push($middleware, 'google_auth');
|
||||
$config['auth'] = 'scoped';
|
||||
$http = new Client($config);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
public function attachKey(ClientInterface $http, $key)
|
||||
{
|
||||
$middleware = new SimpleMiddleware(['key' => $key]);
|
||||
|
||||
$config = $http->getConfig();
|
||||
$config['handler']->remove('google_auth');
|
||||
$config['handler']->push($middleware, 'google_auth');
|
||||
$config['auth'] = 'simple';
|
||||
$http = new Client($config);
|
||||
|
||||
return $http;
|
||||
}
|
||||
|
||||
private function createAuthHttp(ClientInterface $http)
|
||||
{
|
||||
return new Client(
|
||||
[
|
||||
'base_uri' => $http->getConfig('base_uri'),
|
||||
'http_errors' => true,
|
||||
'verify' => $http->getConfig('verify'),
|
||||
'proxy' => $http->getConfig('proxy'),
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
25
src/AuthHandler/Guzzle7AuthHandler.php
Normal file
25
src/AuthHandler/Guzzle7AuthHandler.php
Normal file
@ -0,0 +1,25 @@
|
||||
<?php
|
||||
/**
|
||||
* Copyright 2020 Google LLC
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
namespace Google\AuthHandler;
|
||||
|
||||
/**
|
||||
* This supports Guzzle 7
|
||||
*/
|
||||
class Guzzle7AuthHandler extends Guzzle6AuthHandler
|
||||
{
|
||||
}
|
||||
1274
src/Client.php
Normal file
1274
src/Client.php
Normal file
File diff suppressed because it is too large
Load Diff
98
src/Collection.php
Normal file
98
src/Collection.php
Normal file
@ -0,0 +1,98 @@
|
||||
<?php
|
||||
|
||||
namespace Google;
|
||||
|
||||
/**
|
||||
* 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 Collection extends Model implements \Iterator, \Countable
|
||||
{
|
||||
protected $collection_key = 'items';
|
||||
|
||||
public function rewind()
|
||||
{
|
||||
if (isset($this->{$this->collection_key})
|
||||
&& is_array($this->{$this->collection_key})) {
|
||||
reset($this->{$this->collection_key});
|
||||
}
|
||||
}
|
||||
|
||||
public function current()
|
||||
{
|
||||
$this->coerceType($this->key());
|
||||
if (is_array($this->{$this->collection_key})) {
|
||||
return current($this->{$this->collection_key});
|
||||
}
|
||||
}
|
||||
|
||||
public function key()
|
||||
{
|
||||
if (isset($this->{$this->collection_key})
|
||||
&& is_array($this->{$this->collection_key})) {
|
||||
return key($this->{$this->collection_key});
|
||||
}
|
||||
}
|
||||
|
||||
public function next()
|
||||
{
|
||||
return next($this->{$this->collection_key});
|
||||
}
|
||||
|
||||
public function valid()
|
||||
{
|
||||
$key = $this->key();
|
||||
return $key !== null && $key !== false;
|
||||
}
|
||||
|
||||
public function count()
|
||||
{
|
||||
if (!isset($this->{$this->collection_key})) {
|
||||
return 0;
|
||||
}
|
||||
return count($this->{$this->collection_key});
|
||||
}
|
||||
|
||||
public function offsetExists($offset)
|
||||
{
|
||||
if (!is_numeric($offset)) {
|
||||
return parent::offsetExists($offset);
|
||||
}
|
||||
return isset($this->{$this->collection_key}[$offset]);
|
||||
}
|
||||
|
||||
public function offsetGet($offset)
|
||||
{
|
||||
if (!is_numeric($offset)) {
|
||||
return parent::offsetGet($offset);
|
||||
}
|
||||
$this->coerceType($offset);
|
||||
return $this->{$this->collection_key}[$offset];
|
||||
}
|
||||
|
||||
public function offsetSet($offset, $value)
|
||||
{
|
||||
if (!is_numeric($offset)) {
|
||||
return parent::offsetSet($offset, $value);
|
||||
}
|
||||
$this->{$this->collection_key}[$offset] = $value;
|
||||
}
|
||||
|
||||
public function offsetUnset($offset)
|
||||
{
|
||||
if (!is_numeric($offset)) {
|
||||
return parent::offsetUnset($offset);
|
||||
}
|
||||
unset($this->{$this->collection_key}[$offset]);
|
||||
}
|
||||
|
||||
private function coerceType($offset)
|
||||
{
|
||||
$keyType = $this->keyType($this->collection_key);
|
||||
if ($keyType && !is_object($this->{$this->collection_key}[$offset])) {
|
||||
$this->{$this->collection_key}[$offset] =
|
||||
new $keyType($this->{$this->collection_key}[$offset]);
|
||||
}
|
||||
}
|
||||
}
|
||||
24
src/Exception.php
Normal file
24
src/Exception.php
Normal file
@ -0,0 +1,24 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google;
|
||||
|
||||
use Exception as BaseException;
|
||||
|
||||
class Exception extends BaseException
|
||||
{
|
||||
}
|
||||
258
src/Http/Batch.php
Normal file
258
src/Http/Batch.php
Normal file
@ -0,0 +1,258 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Http;
|
||||
|
||||
use Google\Client;
|
||||
use Google\Http\REST;
|
||||
use Google\Service\Exception as GoogleServiceException;
|
||||
use GuzzleHttp\Psr7;
|
||||
use GuzzleHttp\Psr7\Request;
|
||||
use GuzzleHttp\Psr7\Response;
|
||||
use Psr\Http\Message\RequestInterface;
|
||||
use Psr\Http\Message\ResponseInterface;
|
||||
|
||||
/**
|
||||
* Class to handle batched requests to the Google API service.
|
||||
*
|
||||
* Note that calls to `Google\Http\Batch::execute()` do not clear the queued
|
||||
* requests. To start a new batch, be sure to create a new instance of this
|
||||
* class.
|
||||
*/
|
||||
class Batch
|
||||
{
|
||||
const BATCH_PATH = 'batch';
|
||||
|
||||
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",
|
||||
);
|
||||
|
||||
/** @var string Multipart Boundary. */
|
||||
private $boundary;
|
||||
|
||||
/** @var array service requests to be executed. */
|
||||
private $requests = array();
|
||||
|
||||
/** @var Client */
|
||||
private $client;
|
||||
|
||||
private $rootUrl;
|
||||
|
||||
private $batchPath;
|
||||
|
||||
public function __construct(
|
||||
Client $client,
|
||||
$boundary = false,
|
||||
$rootUrl = null,
|
||||
$batchPath = null
|
||||
) {
|
||||
$this->client = $client;
|
||||
$this->boundary = $boundary ?: mt_rand();
|
||||
$this->rootUrl = rtrim($rootUrl ?: $this->client->getConfig('base_path'), '/');
|
||||
$this->batchPath = $batchPath ?: self::BATCH_PATH;
|
||||
}
|
||||
|
||||
public function add(RequestInterface $request, $key = false)
|
||||
{
|
||||
if (false == $key) {
|
||||
$key = mt_rand();
|
||||
}
|
||||
|
||||
$this->requests[$key] = $request;
|
||||
}
|
||||
|
||||
public function execute()
|
||||
{
|
||||
$body = '';
|
||||
$classes = array();
|
||||
$batchHttpTemplate = <<<EOF
|
||||
--%s
|
||||
Content-Type: application/http
|
||||
Content-Transfer-Encoding: binary
|
||||
MIME-Version: 1.0
|
||||
Content-ID: %s
|
||||
|
||||
%s
|
||||
%s%s
|
||||
|
||||
|
||||
EOF;
|
||||
|
||||
/** @var RequestInterface $req */
|
||||
foreach ($this->requests as $key => $request) {
|
||||
$firstLine = sprintf(
|
||||
'%s %s HTTP/%s',
|
||||
$request->getMethod(),
|
||||
$request->getRequestTarget(),
|
||||
$request->getProtocolVersion()
|
||||
);
|
||||
|
||||
$content = (string) $request->getBody();
|
||||
|
||||
$headers = '';
|
||||
foreach ($request->getHeaders() as $name => $values) {
|
||||
$headers .= sprintf("%s:%s\r\n", $name, implode(', ', $values));
|
||||
}
|
||||
|
||||
$body .= sprintf(
|
||||
$batchHttpTemplate,
|
||||
$this->boundary,
|
||||
$key,
|
||||
$firstLine,
|
||||
$headers,
|
||||
$content ? "\n".$content : ''
|
||||
);
|
||||
|
||||
$classes['response-' . $key] = $request->getHeaderLine('X-Php-Expected-Class');
|
||||
}
|
||||
|
||||
$body .= "--{$this->boundary}--";
|
||||
$body = trim($body);
|
||||
$url = $this->rootUrl . '/' . $this->batchPath;
|
||||
$headers = array(
|
||||
'Content-Type' => sprintf('multipart/mixed; boundary=%s', $this->boundary),
|
||||
'Content-Length' => strlen($body),
|
||||
);
|
||||
|
||||
$request = new Request(
|
||||
'POST',
|
||||
$url,
|
||||
$headers,
|
||||
$body
|
||||
);
|
||||
|
||||
$response = $this->client->execute($request);
|
||||
|
||||
return $this->parseResponse($response, $classes);
|
||||
}
|
||||
|
||||
public function parseResponse(ResponseInterface $response, $classes = array())
|
||||
{
|
||||
$contentType = $response->getHeaderLine('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 = (string) $response->getBody();
|
||||
if (!empty($body)) {
|
||||
$body = str_replace("--$boundary--", "--$boundary", $body);
|
||||
$parts = explode("--$boundary", $body);
|
||||
$responses = array();
|
||||
$requests = array_values($this->requests);
|
||||
|
||||
foreach ($parts as $i => $part) {
|
||||
$part = trim($part);
|
||||
if (!empty($part)) {
|
||||
list($rawHeaders, $part) = explode("\r\n\r\n", $part, 2);
|
||||
$headers = $this->parseRawHeaders($rawHeaders);
|
||||
|
||||
$status = substr($part, 0, strpos($part, "\n"));
|
||||
$status = explode(" ", $status);
|
||||
$status = $status[1];
|
||||
|
||||
list($partHeaders, $partBody) = $this->parseHttpResponse($part, false);
|
||||
$response = new Response(
|
||||
$status,
|
||||
$partHeaders,
|
||||
Psr7\stream_for($partBody)
|
||||
);
|
||||
|
||||
// Need content id.
|
||||
$key = $headers['content-id'];
|
||||
|
||||
try {
|
||||
$response = REST::decodeHttpResponse($response, $requests[$i-1]);
|
||||
} catch (GoogleServiceException $e) {
|
||||
// Store the exception as the response, so successful responses
|
||||
// can be processed.
|
||||
$response = $e;
|
||||
}
|
||||
|
||||
$responses[$key] = $response;
|
||||
}
|
||||
}
|
||||
|
||||
return $responses;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private function parseRawHeaders($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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Used by the IO lib and also the batch processing.
|
||||
*
|
||||
* @param $respData
|
||||
* @param $headerSize
|
||||
* @return array
|
||||
*/
|
||||
private 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.
|
||||
// @TODO look into this
|
||||
// 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->parseRawHeaders($responseHeaders);
|
||||
|
||||
return array($responseHeaders, $responseBody);
|
||||
}
|
||||
}
|
||||
358
src/Http/MediaFileUpload.php
Normal file
358
src/Http/MediaFileUpload.php
Normal file
@ -0,0 +1,358 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Http;
|
||||
|
||||
use Google\Client;
|
||||
use Google\Http\REST;
|
||||
use Google\Exception as GoogleException;
|
||||
use GuzzleHttp\Psr7;
|
||||
use GuzzleHttp\Psr7\Request;
|
||||
use GuzzleHttp\Psr7\Uri;
|
||||
use Psr\Http\Message\RequestInterface;
|
||||
|
||||
/**
|
||||
* Manage large file uploads, which may be media but can be any type
|
||||
* of sizable data.
|
||||
*/
|
||||
class 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 Client */
|
||||
private $client;
|
||||
|
||||
/** @var RequestInterface */
|
||||
private $request;
|
||||
|
||||
/** @var string */
|
||||
private $boundary;
|
||||
|
||||
/**
|
||||
* Result code from last HTTP call
|
||||
* @var int
|
||||
*/
|
||||
private $httpResultCode;
|
||||
|
||||
/**
|
||||
* @param Client $client
|
||||
* @param RequestInterface $request
|
||||
* @param string $mimeType
|
||||
* @param string $data The bytes you want to upload.
|
||||
* @param bool $resumable
|
||||
* @param bool $chunkSize File will be uploaded in chunks of this many bytes.
|
||||
* only used if resumable=True
|
||||
*/
|
||||
public function __construct(
|
||||
Client $client,
|
||||
RequestInterface $request,
|
||||
$mimeType,
|
||||
$data,
|
||||
$resumable = false,
|
||||
$chunkSize = false
|
||||
) {
|
||||
$this->client = $client;
|
||||
$this->request = $request;
|
||||
$this->mimeType = $mimeType;
|
||||
$this->data = $data;
|
||||
$this->resumable = $resumable;
|
||||
$this->chunkSize = $chunkSize;
|
||||
$this->progress = 0;
|
||||
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the next part of the file to upload.
|
||||
* @param string|bool $chunk Optional. The next set of bytes to send. If false will
|
||||
* use $data passed at construct time.
|
||||
*/
|
||||
public function nextChunk($chunk = false)
|
||||
{
|
||||
$resumeUri = $this->getResumeUri();
|
||||
|
||||
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-length' => strlen($chunk),
|
||||
'expect' => '',
|
||||
);
|
||||
|
||||
$request = new Request(
|
||||
'PUT',
|
||||
$resumeUri,
|
||||
$headers,
|
||||
Psr7\stream_for($chunk)
|
||||
);
|
||||
|
||||
return $this->makePutRequest($request);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 RequestInterface $request the Request which will be send
|
||||
*
|
||||
* @return false|mixed false when the upload is unfinished or the decoded http response
|
||||
*
|
||||
*/
|
||||
private function makePutRequest(RequestInterface $request)
|
||||
{
|
||||
$response = $this->client->execute($request);
|
||||
$this->httpResultCode = $response->getStatusCode();
|
||||
|
||||
if (308 == $this->httpResultCode) {
|
||||
// Track the amount uploaded.
|
||||
$range = $response->getHeaderLine('range');
|
||||
if ($range) {
|
||||
$range_array = explode('-', $range);
|
||||
$this->progress = $range_array[1] + 1;
|
||||
}
|
||||
|
||||
// Allow for changing upload URLs.
|
||||
$location = $response->getHeaderLine('location');
|
||||
if ($location) {
|
||||
$this->resumeUri = $location;
|
||||
}
|
||||
|
||||
// No problems, but upload not complete.
|
||||
return false;
|
||||
}
|
||||
|
||||
return REST::decodeHttpResponse($response, $this->request);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 Request(
|
||||
'PUT',
|
||||
$this->resumeUri,
|
||||
$headers
|
||||
);
|
||||
|
||||
return $this->makePutRequest($httpRequest);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return RequestInterface
|
||||
* @visible for testing
|
||||
*/
|
||||
private function process()
|
||||
{
|
||||
$this->transformToUploadUrl();
|
||||
$request = $this->request;
|
||||
|
||||
$postBody = '';
|
||||
$contentType = false;
|
||||
|
||||
$meta = (string) $request->getBody();
|
||||
$meta = is_string($meta) ? json_decode($meta, true) : $meta;
|
||||
|
||||
$uploadType = $this->getUploadType($meta);
|
||||
$request = $request->withUri(
|
||||
Uri::withQueryValue($request->getUri(), 'uploadType', $uploadType)
|
||||
);
|
||||
|
||||
$mimeType = $this->mimeType ?: $request->getHeaderLine('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 ?: 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;
|
||||
}
|
||||
|
||||
$request = $request->withBody(Psr7\stream_for($postBody));
|
||||
|
||||
if (isset($contentType) && $contentType) {
|
||||
$request = $request->withHeader('content-type', $contentType);
|
||||
}
|
||||
|
||||
return $this->request = $request;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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()
|
||||
{
|
||||
if (null === $this->resumeUri) {
|
||||
$this->resumeUri = $this->fetchResumeUri();
|
||||
}
|
||||
|
||||
return $this->resumeUri;
|
||||
}
|
||||
|
||||
private function fetchResumeUri()
|
||||
{
|
||||
$body = $this->request->getBody();
|
||||
if ($body) {
|
||||
$headers = array(
|
||||
'content-type' => 'application/json; charset=UTF-8',
|
||||
'content-length' => $body->getSize(),
|
||||
'x-upload-content-type' => $this->mimeType,
|
||||
'x-upload-content-length' => $this->size,
|
||||
'expect' => '',
|
||||
);
|
||||
foreach ($headers as $key => $value) {
|
||||
$this->request = $this->request->withHeader($key, $value);
|
||||
}
|
||||
}
|
||||
|
||||
$response = $this->client->execute($this->request, false);
|
||||
$location = $response->getHeaderLine('location');
|
||||
$code = $response->getStatusCode();
|
||||
|
||||
if (200 == $code && true == $location) {
|
||||
return $location;
|
||||
}
|
||||
|
||||
$message = $code;
|
||||
$body = json_decode((string) $this->request->getBody(), true);
|
||||
if (isset($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 GoogleException($error);
|
||||
}
|
||||
|
||||
private function transformToUploadUrl()
|
||||
{
|
||||
$parts = parse_url((string) $this->request->getUri());
|
||||
if (!isset($parts['path'])) {
|
||||
$parts['path'] = '';
|
||||
}
|
||||
$parts['path'] = '/upload' . $parts['path'];
|
||||
$uri = Uri::fromParts($parts);
|
||||
$this->request = $this->request->withUri($uri);
|
||||
}
|
||||
|
||||
public function setChunkSize($chunkSize)
|
||||
{
|
||||
$this->chunkSize = $chunkSize;
|
||||
}
|
||||
|
||||
public function getRequest()
|
||||
{
|
||||
return $this->request;
|
||||
}
|
||||
}
|
||||
192
src/Http/REST.php
Normal file
192
src/Http/REST.php
Normal file
@ -0,0 +1,192 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Http;
|
||||
|
||||
use Google\Auth\HttpHandler\HttpHandlerFactory;
|
||||
use Google\Client;
|
||||
use Google\Task\Runner;
|
||||
use Google\Service\Exception as GoogleServiceException;
|
||||
use GuzzleHttp\ClientInterface;
|
||||
use GuzzleHttp\Exception\RequestException;
|
||||
use GuzzleHttp\Psr7\Response;
|
||||
use Psr\Http\Message\RequestInterface;
|
||||
use Psr\Http\Message\ResponseInterface;
|
||||
|
||||
/**
|
||||
* This class implements the RESTful transport of apiServiceRequest()'s
|
||||
*/
|
||||
class REST
|
||||
{
|
||||
/**
|
||||
* Executes a Psr\Http\Message\RequestInterface and (if applicable) automatically retries
|
||||
* when errors occur.
|
||||
*
|
||||
* @param Client $client
|
||||
* @param RequestInterface $req
|
||||
* @param string $expectedClass
|
||||
* @param array $config
|
||||
* @param array $retryMap
|
||||
* @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(
|
||||
ClientInterface $client,
|
||||
RequestInterface $request,
|
||||
$expectedClass = null,
|
||||
$config = array(),
|
||||
$retryMap = null
|
||||
) {
|
||||
$runner = new Runner(
|
||||
$config,
|
||||
sprintf('%s %s', $request->getMethod(), (string) $request->getUri()),
|
||||
array(get_class(), 'doExecute'),
|
||||
array($client, $request, $expectedClass)
|
||||
);
|
||||
|
||||
if (null !== $retryMap) {
|
||||
$runner->setRetryMap($retryMap);
|
||||
}
|
||||
|
||||
return $runner->run();
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes a Psr\Http\Message\RequestInterface
|
||||
*
|
||||
* @param Client $client
|
||||
* @param RequestInterface $request
|
||||
* @param string $expectedClass
|
||||
* @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(ClientInterface $client, RequestInterface $request, $expectedClass = null)
|
||||
{
|
||||
try {
|
||||
$httpHandler = HttpHandlerFactory::build($client);
|
||||
$response = $httpHandler($request);
|
||||
} catch (RequestException $e) {
|
||||
// if Guzzle throws an exception, catch it and handle the response
|
||||
if (!$e->hasResponse()) {
|
||||
throw $e;
|
||||
}
|
||||
|
||||
$response = $e->getResponse();
|
||||
// specific checking for Guzzle 5: convert to PSR7 response
|
||||
if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
|
||||
$response = new Response(
|
||||
$response->getStatusCode(),
|
||||
$response->getHeaders() ?: [],
|
||||
$response->getBody(),
|
||||
$response->getProtocolVersion(),
|
||||
$response->getReasonPhrase()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return self::decodeHttpResponse($response, $request, $expectedClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode an HTTP Response.
|
||||
* @static
|
||||
* @throws \Google\Service\Exception
|
||||
* @param RequestInterface $response The http response to be decoded.
|
||||
* @param ResponseInterface $response
|
||||
* @param string $expectedClass
|
||||
* @return mixed|null
|
||||
*/
|
||||
public static function decodeHttpResponse(
|
||||
ResponseInterface $response,
|
||||
RequestInterface $request = null,
|
||||
$expectedClass = null
|
||||
) {
|
||||
$code = $response->getStatusCode();
|
||||
|
||||
// retry strategy
|
||||
if (intVal($code) >= 400) {
|
||||
// if we errored out, it should be safe to grab the response body
|
||||
$body = (string) $response->getBody();
|
||||
|
||||
// Check if we received errors, and add those to the Exception for convenience
|
||||
throw new GoogleServiceException($body, $code, null, self::getResponseErrors($body));
|
||||
}
|
||||
|
||||
// Ensure we only pull the entire body into memory if the request is not
|
||||
// of media type
|
||||
$body = self::decodeBody($response, $request);
|
||||
|
||||
if ($expectedClass = self::determineExpectedClass($expectedClass, $request)) {
|
||||
$json = json_decode($body, true);
|
||||
|
||||
return new $expectedClass($json);
|
||||
}
|
||||
|
||||
return $response;
|
||||
}
|
||||
|
||||
private static function decodeBody(ResponseInterface $response, RequestInterface $request = null)
|
||||
{
|
||||
if (self::isAltMedia($request)) {
|
||||
// don't decode the body, it's probably a really long string
|
||||
return '';
|
||||
}
|
||||
|
||||
return (string) $response->getBody();
|
||||
}
|
||||
|
||||
private static function determineExpectedClass($expectedClass, RequestInterface $request = null)
|
||||
{
|
||||
// "false" is used to explicitly prevent an expected class from being returned
|
||||
if (false === $expectedClass) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// if we don't have a request, we just use what's passed in
|
||||
if (null === $request) {
|
||||
return $expectedClass;
|
||||
}
|
||||
|
||||
// return what we have in the request header if one was not supplied
|
||||
return $expectedClass ?: $request->getHeaderLine('X-Php-Expected-Class');
|
||||
}
|
||||
|
||||
private static function getResponseErrors($body)
|
||||
{
|
||||
$json = json_decode($body, true);
|
||||
|
||||
if (isset($json['error']['errors'])) {
|
||||
return $json['error']['errors'];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static function isAltMedia(RequestInterface $request = null)
|
||||
{
|
||||
if ($request && $qs = $request->getUri()->getQuery()) {
|
||||
parse_str($qs, $query);
|
||||
if (isset($query['alt']) && $query['alt'] == 'media') {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
324
src/Model.php
Normal file
324
src/Model.php
Normal file
@ -0,0 +1,324 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google;
|
||||
|
||||
use Google\Exception as GoogleException;
|
||||
use ReflectionObject;
|
||||
use ReflectionProperty;
|
||||
use stdClass;
|
||||
|
||||
/**
|
||||
* 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 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)
|
||||
{
|
||||
$keyType = $this->keyType($key);
|
||||
$keyDataType = $this->dataType($key);
|
||||
if ($keyType && !isset($this->processed[$key])) {
|
||||
if (isset($this->modelData[$key])) {
|
||||
$val = $this->modelData[$key];
|
||||
} elseif ($keyDataType == 'array' || $keyDataType == 'map') {
|
||||
$val = array();
|
||||
} else {
|
||||
$val = null;
|
||||
}
|
||||
|
||||
if ($this->isAssociativeArray($val)) {
|
||||
if ($keyDataType && 'map' == $keyDataType) {
|
||||
foreach ($val as $arrayKey => $arrayItem) {
|
||||
$this->modelData[$key][$arrayKey] =
|
||||
new $keyType($arrayItem);
|
||||
}
|
||||
} else {
|
||||
$this->modelData[$key] = new $keyType($val);
|
||||
}
|
||||
} else if (is_array($val)) {
|
||||
$arrayObject = array();
|
||||
foreach ($val as $arrayIndex => $arrayItem) {
|
||||
$arrayObject[$arrayIndex] = new $keyType($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 ($keyType = $this->keyType($key)) {
|
||||
$dataType = $this->dataType($key);
|
||||
if ($dataType == 'array' || $dataType == 'map') {
|
||||
$this->$key = array();
|
||||
foreach ($val as $itemKey => $itemVal) {
|
||||
if ($itemVal instanceof $keyType) {
|
||||
$this->{$key}[$itemKey] = $itemVal;
|
||||
} else {
|
||||
$this->{$key}[$itemKey] = new $keyType($itemVal);
|
||||
}
|
||||
}
|
||||
} elseif ($val instanceof $keyType) {
|
||||
$this->$key = $val;
|
||||
} else {
|
||||
$this->$key = new $keyType($val);
|
||||
}
|
||||
unset($array[$key]);
|
||||
} elseif (property_exists($this, $key)) {
|
||||
$this->$key = $val;
|
||||
unset($array[$key]);
|
||||
} elseif (property_exists($this, $camelKey = $this->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 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, $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;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 GoogleException(
|
||||
"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)
|
||||
{
|
||||
$keyType = $key . "Type";
|
||||
|
||||
// ensure keyType is a valid class
|
||||
if (property_exists($this, $keyType) && class_exists($this->$keyType)) {
|
||||
return $this->$keyType;
|
||||
}
|
||||
}
|
||||
|
||||
protected function dataType($key)
|
||||
{
|
||||
$dataType = $key . "DataType";
|
||||
|
||||
if (property_exists($this, $dataType)) {
|
||||
return $this->$dataType;
|
||||
}
|
||||
}
|
||||
|
||||
public function __isset($key)
|
||||
{
|
||||
return isset($this->modelData[$key]);
|
||||
}
|
||||
|
||||
public function __unset($key)
|
||||
{
|
||||
unset($this->modelData[$key]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a string to camelCase
|
||||
* @param string $value
|
||||
* @return string
|
||||
*/
|
||||
private function camelCase($value)
|
||||
{
|
||||
$value = ucwords(str_replace(array('-', '_'), ' ', $value));
|
||||
$value = str_replace(' ', '', $value);
|
||||
$value[0] = strtolower($value[0]);
|
||||
return $value;
|
||||
}
|
||||
}
|
||||
71
src/Service.php
Normal file
71
src/Service.php
Normal file
@ -0,0 +1,71 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google;
|
||||
|
||||
use Google\Http\Batch;
|
||||
use TypeError;
|
||||
|
||||
class Service
|
||||
{
|
||||
public $batchPath;
|
||||
public $rootUrl;
|
||||
public $version;
|
||||
public $servicePath;
|
||||
public $availableScopes;
|
||||
public $resource;
|
||||
private $client;
|
||||
|
||||
public function __construct($clientOrConfig = [])
|
||||
{
|
||||
if ($clientOrConfig instanceof Client) {
|
||||
$this->client = $clientOrConfig;
|
||||
} elseif (is_array($clientOrConfig)) {
|
||||
$this->client = new Client($clientOrConfig ?: []);
|
||||
} else {
|
||||
$errorMessage = 'constructor must be array or instance of Google\Client';
|
||||
if (class_exists('TypeError')) {
|
||||
throw new TypeError($errorMessage);
|
||||
}
|
||||
trigger_error($errorMessage, E_USER_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 Batch
|
||||
*/
|
||||
public function createBatch()
|
||||
{
|
||||
return new Batch(
|
||||
$this->client,
|
||||
false,
|
||||
$this->rootUrl,
|
||||
$this->batchPath
|
||||
);
|
||||
}
|
||||
}
|
||||
71
src/Service/Exception.php
Normal file
71
src/Service/Exception.php
Normal file
@ -0,0 +1,71 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Service;
|
||||
|
||||
use Google\Exception as GoogleException;
|
||||
|
||||
class Exception extends GoogleException
|
||||
{
|
||||
/**
|
||||
* Optional list of errors returned in a JSON body of an HTTP error response.
|
||||
*/
|
||||
protected $errors = 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 [].
|
||||
*/
|
||||
public function __construct(
|
||||
$message,
|
||||
$code = 0,
|
||||
Exception $previous = null,
|
||||
$errors = array()
|
||||
) {
|
||||
if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
|
||||
parent::__construct($message, $code, $previous);
|
||||
} else {
|
||||
parent::__construct($message, $code);
|
||||
}
|
||||
|
||||
$this->errors = $errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
5
src/Service/README.md
Normal file
5
src/Service/README.md
Normal file
@ -0,0 +1,5 @@
|
||||
# Google API Client Services
|
||||
|
||||
Google API Client Service classes have been moved to the
|
||||
[google-api-php-client-services](https://github.com/google/google-api-php-client-services)
|
||||
repository.
|
||||
308
src/Service/Resource.php
Normal file
308
src/Service/Resource.php
Normal file
@ -0,0 +1,308 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Service;
|
||||
|
||||
use Google\Model;
|
||||
use Google\Http\MediaFileUpload;
|
||||
use Google\Exception as GoogleException;
|
||||
use Google\Utils\UriTemplate;
|
||||
use GuzzleHttp\Psr7\Request;
|
||||
|
||||
/**
|
||||
* Implements the actual methods/resources of the discovered Google API using magic function
|
||||
* calling overloading (__call()), which on call will see if the method name (plus.activities.list)
|
||||
* is available in this service, and if so construct an apiHttpRequest representing it.
|
||||
*
|
||||
*/
|
||||
class Resource
|
||||
{
|
||||
// Valid query parameters that work, but don't appear in discovery.
|
||||
private $stackParameters = array(
|
||||
'alt' => array('type' => 'string', 'location' => 'query'),
|
||||
'fields' => array('type' => 'string', 'location' => 'query'),
|
||||
'trace' => array('type' => 'string', 'location' => 'query'),
|
||||
'userIp' => array('type' => 'string', 'location' => 'query'),
|
||||
'quotaUser' => array('type' => 'string', 'location' => 'query'),
|
||||
'data' => array('type' => 'string', 'location' => 'body'),
|
||||
'mimeType' => array('type' => 'string', 'location' => 'header'),
|
||||
'uploadType' => array('type' => 'string', 'location' => 'query'),
|
||||
'mediaUpload' => array('type' => 'complex', 'location' => 'query'),
|
||||
'prettyPrint' => array('type' => 'string', 'location' => 'query'),
|
||||
);
|
||||
|
||||
/** @var string $rootUrl */
|
||||
private $rootUrl;
|
||||
|
||||
/** @var \Google\Client $client */
|
||||
private $client;
|
||||
|
||||
/** @var string $serviceName */
|
||||
private $serviceName;
|
||||
|
||||
/** @var string $servicePath */
|
||||
private $servicePath;
|
||||
|
||||
/** @var string $resourceName */
|
||||
private $resourceName;
|
||||
|
||||
/** @var array $methods */
|
||||
private $methods;
|
||||
|
||||
public function __construct($service, $serviceName, $resourceName, $resource)
|
||||
{
|
||||
$this->rootUrl = $service->rootUrl;
|
||||
$this->client = $service->getClient();
|
||||
$this->servicePath = $service->servicePath;
|
||||
$this->serviceName = $serviceName;
|
||||
$this->resourceName = $resourceName;
|
||||
$this->methods = is_array($resource) && isset($resource['methods']) ?
|
||||
$resource['methods'] :
|
||||
array($resourceName => $resource);
|
||||
}
|
||||
|
||||
/**
|
||||
* TODO: This function needs simplifying.
|
||||
* @param $name
|
||||
* @param $arguments
|
||||
* @param $expectedClass - optional, the expected class name
|
||||
* @return Request|$expectedClass
|
||||
* @throws \Google\Exception
|
||||
*/
|
||||
public function call($name, $arguments, $expectedClass = null)
|
||||
{
|
||||
if (! isset($this->methods[$name])) {
|
||||
$this->client->getLogger()->error(
|
||||
'Service method unknown',
|
||||
array(
|
||||
'service' => $this->serviceName,
|
||||
'resource' => $this->resourceName,
|
||||
'method' => $name
|
||||
)
|
||||
);
|
||||
|
||||
throw new GoogleException(
|
||||
"Unknown function: " .
|
||||
"{$this->serviceName}->{$this->resourceName}->{$name}()"
|
||||
);
|
||||
}
|
||||
$method = $this->methods[$name];
|
||||
$parameters = $arguments[0];
|
||||
|
||||
// postBody is a special case since it's not defined in the discovery
|
||||
// document as parameter, but we abuse the param entry for storing it.
|
||||
$postBody = null;
|
||||
if (isset($parameters['postBody'])) {
|
||||
if ($parameters['postBody'] instanceof Model) {
|
||||
// In the cases the post body is an existing object, we want
|
||||
// to use the smart method to create a simple object for
|
||||
// for JSONification.
|
||||
$parameters['postBody'] = $parameters['postBody']->toSimpleObject();
|
||||
} else if (is_object($parameters['postBody'])) {
|
||||
// If the post body is another kind of object, we will try and
|
||||
// wrangle it into a sensible format.
|
||||
$parameters['postBody'] =
|
||||
$this->convertToArrayAndStripNulls($parameters['postBody']);
|
||||
}
|
||||
$postBody = (array) $parameters['postBody'];
|
||||
unset($parameters['postBody']);
|
||||
}
|
||||
|
||||
// TODO: optParams here probably should have been
|
||||
// handled already - this may well be redundant code.
|
||||
if (isset($parameters['optParams'])) {
|
||||
$optParams = $parameters['optParams'];
|
||||
unset($parameters['optParams']);
|
||||
$parameters = array_merge($parameters, $optParams);
|
||||
}
|
||||
|
||||
if (!isset($method['parameters'])) {
|
||||
$method['parameters'] = array();
|
||||
}
|
||||
|
||||
$method['parameters'] = array_merge(
|
||||
$this->stackParameters,
|
||||
$method['parameters']
|
||||
);
|
||||
|
||||
foreach ($parameters as $key => $val) {
|
||||
if ($key != 'postBody' && ! isset($method['parameters'][$key])) {
|
||||
$this->client->getLogger()->error(
|
||||
'Service parameter unknown',
|
||||
array(
|
||||
'service' => $this->serviceName,
|
||||
'resource' => $this->resourceName,
|
||||
'method' => $name,
|
||||
'parameter' => $key
|
||||
)
|
||||
);
|
||||
throw new GoogleException("($name) unknown parameter: '$key'");
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($method['parameters'] as $paramName => $paramSpec) {
|
||||
if (isset($paramSpec['required']) &&
|
||||
$paramSpec['required'] &&
|
||||
! isset($parameters[$paramName])
|
||||
) {
|
||||
$this->client->getLogger()->error(
|
||||
'Service parameter missing',
|
||||
array(
|
||||
'service' => $this->serviceName,
|
||||
'resource' => $this->resourceName,
|
||||
'method' => $name,
|
||||
'parameter' => $paramName
|
||||
)
|
||||
);
|
||||
throw new GoogleException("($name) missing required param: '$paramName'");
|
||||
}
|
||||
if (isset($parameters[$paramName])) {
|
||||
$value = $parameters[$paramName];
|
||||
$parameters[$paramName] = $paramSpec;
|
||||
$parameters[$paramName]['value'] = $value;
|
||||
unset($parameters[$paramName]['required']);
|
||||
} else {
|
||||
// Ensure we don't pass nulls.
|
||||
unset($parameters[$paramName]);
|
||||
}
|
||||
}
|
||||
|
||||
$this->client->getLogger()->info(
|
||||
'Service Call',
|
||||
array(
|
||||
'service' => $this->serviceName,
|
||||
'resource' => $this->resourceName,
|
||||
'method' => $name,
|
||||
'arguments' => $parameters,
|
||||
)
|
||||
);
|
||||
|
||||
// build the service uri
|
||||
$url = $this->createRequestUri(
|
||||
$method['path'],
|
||||
$parameters
|
||||
);
|
||||
|
||||
// NOTE: because we're creating the request by hand,
|
||||
// and because the service has a rootUrl property
|
||||
// the "base_uri" of the Http Client is not accounted for
|
||||
$request = new Request(
|
||||
$method['httpMethod'],
|
||||
$url,
|
||||
['content-type' => 'application/json'],
|
||||
$postBody ? json_encode($postBody) : ''
|
||||
);
|
||||
|
||||
// support uploads
|
||||
if (isset($parameters['data'])) {
|
||||
$mimeType = isset($parameters['mimeType'])
|
||||
? $parameters['mimeType']['value']
|
||||
: 'application/octet-stream';
|
||||
$data = $parameters['data']['value'];
|
||||
$upload = new MediaFileUpload($this->client, $request, $mimeType, $data);
|
||||
|
||||
// pull down the modified request
|
||||
$request = $upload->getRequest();
|
||||
}
|
||||
|
||||
// if this is a media type, we will return the raw response
|
||||
// rather than using an expected class
|
||||
if (isset($parameters['alt']) && $parameters['alt']['value'] == 'media') {
|
||||
$expectedClass = null;
|
||||
}
|
||||
|
||||
// if the client is marked for deferring, rather than
|
||||
// execute the request, return the response
|
||||
if ($this->client->shouldDefer()) {
|
||||
// @TODO find a better way to do this
|
||||
$request = $request
|
||||
->withHeader('X-Php-Expected-Class', $expectedClass);
|
||||
|
||||
return $request;
|
||||
}
|
||||
|
||||
return $this->client->execute($request, $expectedClass);
|
||||
}
|
||||
|
||||
protected function convertToArrayAndStripNulls($o)
|
||||
{
|
||||
$o = (array) $o;
|
||||
foreach ($o as $k => $v) {
|
||||
if ($v === null) {
|
||||
unset($o[$k]);
|
||||
} elseif (is_object($v) || is_array($v)) {
|
||||
$o[$k] = $this->convertToArrayAndStripNulls($o[$k]);
|
||||
}
|
||||
}
|
||||
return $o;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse/expand request parameters and create a fully qualified
|
||||
* request uri.
|
||||
* @static
|
||||
* @param string $restPath
|
||||
* @param array $params
|
||||
* @return string $requestUrl
|
||||
*/
|
||||
public function createRequestUri($restPath, $params)
|
||||
{
|
||||
// Override the default servicePath address if the $restPath use a /
|
||||
if ('/' == substr($restPath, 0, 1)) {
|
||||
$requestUrl = substr($restPath, 1);
|
||||
} else {
|
||||
$requestUrl = $this->servicePath . $restPath;
|
||||
}
|
||||
|
||||
// code for leading slash
|
||||
if ($this->rootUrl) {
|
||||
if ('/' !== substr($this->rootUrl, -1) && '/' !== substr($requestUrl, 0, 1)) {
|
||||
$requestUrl = '/' . $requestUrl;
|
||||
}
|
||||
$requestUrl = $this->rootUrl . $requestUrl;
|
||||
}
|
||||
$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 (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 UriTemplate();
|
||||
$requestUrl = $uriTemplateParser->parse($requestUrl, $uriTemplateVars);
|
||||
}
|
||||
|
||||
if (count($queryVars)) {
|
||||
$requestUrl .= '?' . implode('&', $queryVars);
|
||||
}
|
||||
|
||||
return $requestUrl;
|
||||
}
|
||||
}
|
||||
107
src/Task/Composer.php
Normal file
107
src/Task/Composer.php
Normal file
@ -0,0 +1,107 @@
|
||||
<?php
|
||||
/*
|
||||
* Copyright 2020 Google LLC
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
namespace Google\Task;
|
||||
|
||||
use Composer\Script\Event;
|
||||
use Symfony\Component\Filesystem\Filesystem;
|
||||
use Symfony\Component\Finder\Finder;
|
||||
use InvalidArgumentException;
|
||||
|
||||
class Composer
|
||||
{
|
||||
/**
|
||||
* @param Event $event Composer event passed in for any script method
|
||||
* @param Filesystem $filesystem Optional. Used for testing.
|
||||
*/
|
||||
public static function cleanup(
|
||||
Event $event,
|
||||
Filesystem $filesystem = null
|
||||
) {
|
||||
$composer = $event->getComposer();
|
||||
$extra = $composer->getPackage()->getExtra();
|
||||
$servicesToKeep = isset($extra['google/apiclient-services']) ?
|
||||
$extra['google/apiclient-services'] : [];
|
||||
if ($servicesToKeep) {
|
||||
$serviceDir = sprintf(
|
||||
'%s/google/apiclient-services/src/Google/Service',
|
||||
$composer->getConfig()->get('vendor-dir')
|
||||
);
|
||||
self::verifyServicesToKeep($serviceDir, $servicesToKeep);
|
||||
$finder = self::getServicesToRemove($serviceDir, $servicesToKeep);
|
||||
$filesystem = $filesystem ?: new Filesystem();
|
||||
if (0 !== $count = count($finder)) {
|
||||
$event->getIO()->write(
|
||||
sprintf(
|
||||
'Removing %s google services',
|
||||
$count
|
||||
)
|
||||
);
|
||||
foreach ($finder as $file) {
|
||||
$realpath = $file->getRealPath();
|
||||
$filesystem->remove($realpath);
|
||||
$filesystem->remove($realpath . '.php');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws InvalidArgumentException when the service doesn't exist
|
||||
*/
|
||||
private static function verifyServicesToKeep(
|
||||
$serviceDir,
|
||||
array $servicesToKeep
|
||||
) {
|
||||
$finder = (new Finder())
|
||||
->directories()
|
||||
->depth('== 0');
|
||||
|
||||
foreach ($servicesToKeep as $service) {
|
||||
if (!preg_match('/^[a-zA-Z0-9]*$/', $service)) {
|
||||
throw new InvalidArgumentException(
|
||||
sprintf(
|
||||
'Invalid Google service name "%s"',
|
||||
$service
|
||||
)
|
||||
);
|
||||
}
|
||||
try {
|
||||
$finder->in($serviceDir . '/' . $service);
|
||||
} catch (InvalidArgumentException $e) {
|
||||
throw new InvalidArgumentException(
|
||||
sprintf(
|
||||
'Google service "%s" does not exist or was removed previously',
|
||||
$service
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static function getServicesToRemove(
|
||||
$serviceDir,
|
||||
array $servicesToKeep
|
||||
) {
|
||||
// find all files in the current directory
|
||||
return (new Finder())
|
||||
->directories()
|
||||
->depth('== 0')
|
||||
->in($serviceDir)
|
||||
->exclude($servicesToKeep);
|
||||
}
|
||||
}
|
||||
24
src/Task/Exception.php
Normal file
24
src/Task/Exception.php
Normal file
@ -0,0 +1,24 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Task;
|
||||
|
||||
use Google\Exception as GoogleException;
|
||||
|
||||
class Exception extends GoogleException
|
||||
{
|
||||
}
|
||||
26
src/Task/Retryable.php
Normal file
26
src/Task/Retryable.php
Normal file
@ -0,0 +1,26 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Task;
|
||||
|
||||
/**
|
||||
* Interface for checking how many times a given task can be retried following
|
||||
* a failure.
|
||||
*/
|
||||
interface Retryable
|
||||
{
|
||||
}
|
||||
286
src/Task/Runner.php
Normal file
286
src/Task/Runner.php
Normal file
@ -0,0 +1,286 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Task;
|
||||
|
||||
use Google\Service\Exception as GoogleServiceException;
|
||||
use Google\Task\Exception as GoogleTaskException;
|
||||
|
||||
/**
|
||||
* A task runner with exponential backoff support.
|
||||
*
|
||||
* @see https://developers.google.com/drive/web/handle-errors#implementing_exponential_backoff
|
||||
*/
|
||||
class Runner
|
||||
{
|
||||
const TASK_RETRY_NEVER = 0;
|
||||
const TASK_RETRY_ONCE = 1;
|
||||
const TASK_RETRY_ALWAYS = -1;
|
||||
|
||||
/**
|
||||
* @var integer $maxDelay The max time (in seconds) to wait before a retry.
|
||||
*/
|
||||
private $maxDelay = 60;
|
||||
/**
|
||||
* @var integer $delay The previous delay from which the next is calculated.
|
||||
*/
|
||||
private $delay = 1;
|
||||
|
||||
/**
|
||||
* @var integer $factor The base number for the exponential back off.
|
||||
*/
|
||||
private $factor = 2;
|
||||
/**
|
||||
* @var float $jitter A random number between -$jitter and $jitter will be
|
||||
* added to $factor on each iteration to allow for a better distribution of
|
||||
* retries.
|
||||
*/
|
||||
private $jitter = 0.5;
|
||||
|
||||
/**
|
||||
* @var integer $attempts The number of attempts that have been tried so far.
|
||||
*/
|
||||
private $attempts = 0;
|
||||
/**
|
||||
* @var integer $maxAttempts The max number of attempts allowed.
|
||||
*/
|
||||
private $maxAttempts = 1;
|
||||
|
||||
/**
|
||||
* @var callable $action The task to run and possibly retry.
|
||||
*/
|
||||
private $action;
|
||||
/**
|
||||
* @var array $arguments The task arguments.
|
||||
*/
|
||||
private $arguments;
|
||||
|
||||
/**
|
||||
* @var array $retryMap Map of errors with retry counts.
|
||||
*/
|
||||
protected $retryMap = [
|
||||
'500' => self::TASK_RETRY_ALWAYS,
|
||||
'503' => self::TASK_RETRY_ALWAYS,
|
||||
'rateLimitExceeded' => self::TASK_RETRY_ALWAYS,
|
||||
'userRateLimitExceeded' => self::TASK_RETRY_ALWAYS,
|
||||
6 => self::TASK_RETRY_ALWAYS, // CURLE_COULDNT_RESOLVE_HOST
|
||||
7 => self::TASK_RETRY_ALWAYS, // CURLE_COULDNT_CONNECT
|
||||
28 => self::TASK_RETRY_ALWAYS, // CURLE_OPERATION_TIMEOUTED
|
||||
35 => self::TASK_RETRY_ALWAYS, // CURLE_SSL_CONNECT_ERROR
|
||||
52 => self::TASK_RETRY_ALWAYS // CURLE_GOT_NOTHING
|
||||
];
|
||||
|
||||
/**
|
||||
* Creates a new task runner with exponential backoff support.
|
||||
*
|
||||
* @param array $config The task runner config
|
||||
* @param string $name The name of the current task (used for logging)
|
||||
* @param callable $action The task to run and possibly retry
|
||||
* @param array $arguments The task arguments
|
||||
* @throws \Google\Task\Exception when misconfigured
|
||||
*/
|
||||
public function __construct(
|
||||
$config,
|
||||
$name,
|
||||
$action,
|
||||
array $arguments = array()
|
||||
) {
|
||||
if (isset($config['initial_delay'])) {
|
||||
if ($config['initial_delay'] < 0) {
|
||||
throw new GoogleTaskException(
|
||||
'Task configuration `initial_delay` must not be negative.'
|
||||
);
|
||||
}
|
||||
|
||||
$this->delay = $config['initial_delay'];
|
||||
}
|
||||
|
||||
if (isset($config['max_delay'])) {
|
||||
if ($config['max_delay'] <= 0) {
|
||||
throw new GoogleTaskException(
|
||||
'Task configuration `max_delay` must be greater than 0.'
|
||||
);
|
||||
}
|
||||
|
||||
$this->maxDelay = $config['max_delay'];
|
||||
}
|
||||
|
||||
if (isset($config['factor'])) {
|
||||
if ($config['factor'] <= 0) {
|
||||
throw new GoogleTaskException(
|
||||
'Task configuration `factor` must be greater than 0.'
|
||||
);
|
||||
}
|
||||
|
||||
$this->factor = $config['factor'];
|
||||
}
|
||||
|
||||
if (isset($config['jitter'])) {
|
||||
if ($config['jitter'] <= 0) {
|
||||
throw new GoogleTaskException(
|
||||
'Task configuration `jitter` must be greater than 0.'
|
||||
);
|
||||
}
|
||||
|
||||
$this->jitter = $config['jitter'];
|
||||
}
|
||||
|
||||
if (isset($config['retries'])) {
|
||||
if ($config['retries'] < 0) {
|
||||
throw new GoogleTaskException(
|
||||
'Task configuration `retries` must not be negative.'
|
||||
);
|
||||
}
|
||||
$this->maxAttempts += $config['retries'];
|
||||
}
|
||||
|
||||
if (!is_callable($action)) {
|
||||
throw new GoogleTaskException(
|
||||
'Task argument `$action` must be a valid callable.'
|
||||
);
|
||||
}
|
||||
|
||||
$this->action = $action;
|
||||
$this->arguments = $arguments;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a retry can be attempted.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function canAttempt()
|
||||
{
|
||||
return $this->attempts < $this->maxAttempts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the task and (if applicable) automatically retries when errors occur.
|
||||
*
|
||||
* @return mixed
|
||||
* @throws \Google\Service\Exception on failure when no retries are available.
|
||||
*/
|
||||
public function run()
|
||||
{
|
||||
while ($this->attempt()) {
|
||||
try {
|
||||
return call_user_func_array($this->action, $this->arguments);
|
||||
} catch (GoogleServiceException $exception) {
|
||||
$allowedRetries = $this->allowedRetries(
|
||||
$exception->getCode(),
|
||||
$exception->getErrors()
|
||||
);
|
||||
|
||||
if (!$this->canAttempt() || !$allowedRetries) {
|
||||
throw $exception;
|
||||
}
|
||||
|
||||
if ($allowedRetries > 0) {
|
||||
$this->maxAttempts = min(
|
||||
$this->maxAttempts,
|
||||
$this->attempts + $allowedRetries
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs a task once, if possible. This is useful for bypassing the `run()`
|
||||
* loop.
|
||||
*
|
||||
* NOTE: If this is not the first attempt, this function will sleep in
|
||||
* accordance to the backoff configurations before running the task.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function attempt()
|
||||
{
|
||||
if (!$this->canAttempt()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ($this->attempts > 0) {
|
||||
$this->backOff();
|
||||
}
|
||||
|
||||
$this->attempts++;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sleeps in accordance to the backoff configurations.
|
||||
*/
|
||||
private function backOff()
|
||||
{
|
||||
$delay = $this->getDelay();
|
||||
|
||||
usleep($delay * 1000000);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the delay (in seconds) for the current backoff period.
|
||||
*
|
||||
* @return float
|
||||
*/
|
||||
private function getDelay()
|
||||
{
|
||||
$jitter = $this->getJitter();
|
||||
$factor = $this->attempts > 1 ? $this->factor + $jitter : 1 + abs($jitter);
|
||||
|
||||
return $this->delay = min($this->maxDelay, $this->delay * $factor);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the current jitter (random number between -$this->jitter and
|
||||
* $this->jitter).
|
||||
*
|
||||
* @return float
|
||||
*/
|
||||
private function getJitter()
|
||||
{
|
||||
return $this->jitter * 2 * mt_rand() / mt_getrandmax() - $this->jitter;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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($code, $errors = array())
|
||||
{
|
||||
if (isset($this->retryMap[$code])) {
|
||||
return $this->retryMap[$code];
|
||||
}
|
||||
|
||||
if (
|
||||
!empty($errors) &&
|
||||
isset($errors[0]['reason'], $this->retryMap[$errors[0]['reason']])
|
||||
) {
|
||||
return $this->retryMap[$errors[0]['reason']];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function setRetryMap($retryMap)
|
||||
{
|
||||
$this->retryMap = $retryMap;
|
||||
}
|
||||
}
|
||||
335
src/Utils/UriTemplate.php
Normal file
335
src/Utils/UriTemplate.php
Normal file
@ -0,0 +1,335 @@
|
||||
<?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.
|
||||
*/
|
||||
|
||||
namespace Google\Utils;
|
||||
|
||||
/**
|
||||
* Implementation of levels 1-3 of the URI Template spec.
|
||||
* @see http://tools.ietf.org/html/rfc6570
|
||||
*/
|
||||
class UriTemplate
|
||||
{
|
||||
const TYPE_MAP = "1";
|
||||
const TYPE_LIST = "2";
|
||||
const TYPE_SCALAR = "4";
|
||||
|
||||
/**
|
||||
* @var $operators array
|
||||
* These are valid at the start of a template block to
|
||||
* modify the way in which the variables inside are
|
||||
* processed.
|
||||
*/
|
||||
private $operators = array(
|
||||
"+" => "reserved",
|
||||
"/" => "segments",
|
||||
"." => "dotprefix",
|
||||
"#" => "fragment",
|
||||
";" => "semicolon",
|
||||
"?" => "form",
|
||||
"&" => "continuation"
|
||||
);
|
||||
|
||||
/**
|
||||
* @var reserved array
|
||||
* These are the characters which should not be URL encoded in reserved
|
||||
* strings.
|
||||
*/
|
||||
private $reserved = array(
|
||||
"=", ",", "!", "@", "|", ":", "/", "?", "#",
|
||||
"[", "]",'$', "&", "'", "(", ")", "*", "+", ";"
|
||||
);
|
||||
private $reservedEncoded = array(
|
||||
"%3D", "%2C", "%21", "%40", "%7C", "%3A", "%2F", "%3F",
|
||||
"%23", "%5B", "%5D", "%24", "%26", "%27", "%28", "%29",
|
||||
"%2A", "%2B", "%3B"
|
||||
);
|
||||
|
||||
public function parse($string, array $parameters)
|
||||
{
|
||||
return $this->resolveNextSection($string, $parameters);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function finds the first matching {...} block and
|
||||
* executes the replacement. It then calls itself to find
|
||||
* subsequent blocks, if any.
|
||||
*/
|
||||
private function resolveNextSection($string, $parameters)
|
||||
{
|
||||
$start = strpos($string, "{");
|
||||
if ($start === false) {
|
||||
return $string;
|
||||
}
|
||||
$end = strpos($string, "}");
|
||||
if ($end === false) {
|
||||
return $string;
|
||||
}
|
||||
$string = $this->replace($string, $start, $end, $parameters);
|
||||
return $this->resolveNextSection($string, $parameters);
|
||||
}
|
||||
|
||||
private function replace($string, $start, $end, $parameters)
|
||||
{
|
||||
// We know a data block will have {} round it, so we can strip that.
|
||||
$data = substr($string, $start + 1, $end - $start - 1);
|
||||
|
||||
// If the first character is one of the reserved operators, it effects
|
||||
// the processing of the stream.
|
||||
if (isset($this->operators[$data[0]])) {
|
||||
$op = $this->operators[$data[0]];
|
||||
$data = substr($data, 1);
|
||||
$prefix = "";
|
||||
$prefix_on_missing = false;
|
||||
|
||||
switch ($op) {
|
||||
case "reserved":
|
||||
// Reserved means certain characters should not be URL encoded
|
||||
$data = $this->replaceVars($data, $parameters, ",", null, true);
|
||||
break;
|
||||
case "fragment":
|
||||
// Comma separated with fragment prefix. Bare values only.
|
||||
$prefix = "#";
|
||||
$prefix_on_missing = true;
|
||||
$data = $this->replaceVars($data, $parameters, ",", null, true);
|
||||
break;
|
||||
case "segments":
|
||||
// Slash separated data. Bare values only.
|
||||
$prefix = "/";
|
||||
$data =$this->replaceVars($data, $parameters, "/");
|
||||
break;
|
||||
case "dotprefix":
|
||||
// Dot separated data. Bare values only.
|
||||
$prefix = ".";
|
||||
$prefix_on_missing = true;
|
||||
$data = $this->replaceVars($data, $parameters, ".");
|
||||
break;
|
||||
case "semicolon":
|
||||
// Semicolon prefixed and separated. Uses the key name
|
||||
$prefix = ";";
|
||||
$data = $this->replaceVars($data, $parameters, ";", "=", false, true, false);
|
||||
break;
|
||||
case "form":
|
||||
// Standard URL format. Uses the key name
|
||||
$prefix = "?";
|
||||
$data = $this->replaceVars($data, $parameters, "&", "=");
|
||||
break;
|
||||
case "continuation":
|
||||
// Standard URL, but with leading ampersand. Uses key name.
|
||||
$prefix = "&";
|
||||
$data = $this->replaceVars($data, $parameters, "&", "=");
|
||||
break;
|
||||
}
|
||||
|
||||
// Add the initial prefix character if data is valid.
|
||||
if ($data || ($data !== false && $prefix_on_missing)) {
|
||||
$data = $prefix . $data;
|
||||
}
|
||||
|
||||
} else {
|
||||
// If no operator we replace with the defaults.
|
||||
$data = $this->replaceVars($data, $parameters);
|
||||
}
|
||||
// This is chops out the {...} and replaces with the new section.
|
||||
return substr($string, 0, $start) . $data . substr($string, $end + 1);
|
||||
}
|
||||
|
||||
private function replaceVars(
|
||||
$section,
|
||||
$parameters,
|
||||
$sep = ",",
|
||||
$combine = null,
|
||||
$reserved = false,
|
||||
$tag_empty = false,
|
||||
$combine_on_empty = true
|
||||
) {
|
||||
if (strpos($section, ",") === false) {
|
||||
// If we only have a single value, we can immediately process.
|
||||
return $this->combine(
|
||||
$section,
|
||||
$parameters,
|
||||
$sep,
|
||||
$combine,
|
||||
$reserved,
|
||||
$tag_empty,
|
||||
$combine_on_empty
|
||||
);
|
||||
} else {
|
||||
// If we have multiple values, we need to split and loop over them.
|
||||
// Each is treated individually, then glued together with the
|
||||
// separator character.
|
||||
$vars = explode(",", $section);
|
||||
return $this->combineList(
|
||||
$vars,
|
||||
$sep,
|
||||
$parameters,
|
||||
$combine,
|
||||
$reserved,
|
||||
false, // Never emit empty strings in multi-param replacements
|
||||
$combine_on_empty
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
public function combine(
|
||||
$key,
|
||||
$parameters,
|
||||
$sep,
|
||||
$combine,
|
||||
$reserved,
|
||||
$tag_empty,
|
||||
$combine_on_empty
|
||||
) {
|
||||
$length = false;
|
||||
$explode = false;
|
||||
$skip_final_combine = false;
|
||||
$value = false;
|
||||
|
||||
// Check for length restriction.
|
||||
if (strpos($key, ":") !== false) {
|
||||
list($key, $length) = explode(":", $key);
|
||||
}
|
||||
|
||||
// Check for explode parameter.
|
||||
if ($key[strlen($key) - 1] == "*") {
|
||||
$explode = true;
|
||||
$key = substr($key, 0, -1);
|
||||
$skip_final_combine = true;
|
||||
}
|
||||
|
||||
// Define the list separator.
|
||||
$list_sep = $explode ? $sep : ",";
|
||||
|
||||
if (isset($parameters[$key])) {
|
||||
$data_type = $this->getDataType($parameters[$key]);
|
||||
switch ($data_type) {
|
||||
case self::TYPE_SCALAR:
|
||||
$value = $this->getValue($parameters[$key], $length);
|
||||
break;
|
||||
case self::TYPE_LIST:
|
||||
$values = array();
|
||||
foreach ($parameters[$key] as $pkey => $pvalue) {
|
||||
$pvalue = $this->getValue($pvalue, $length);
|
||||
if ($combine && $explode) {
|
||||
$values[$pkey] = $key . $combine . $pvalue;
|
||||
} else {
|
||||
$values[$pkey] = $pvalue;
|
||||
}
|
||||
}
|
||||
$value = implode($list_sep, $values);
|
||||
if ($value == '') {
|
||||
return '';
|
||||
}
|
||||
break;
|
||||
case self::TYPE_MAP:
|
||||
$values = array();
|
||||
foreach ($parameters[$key] as $pkey => $pvalue) {
|
||||
$pvalue = $this->getValue($pvalue, $length);
|
||||
if ($explode) {
|
||||
$pkey = $this->getValue($pkey, $length);
|
||||
$values[] = $pkey . "=" . $pvalue; // Explode triggers = combine.
|
||||
} else {
|
||||
$values[] = $pkey;
|
||||
$values[] = $pvalue;
|
||||
}
|
||||
}
|
||||
$value = implode($list_sep, $values);
|
||||
if ($value == '') {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else if ($tag_empty) {
|
||||
// If we are just indicating empty values with their key name, return that.
|
||||
return $key;
|
||||
} else {
|
||||
// Otherwise we can skip this variable due to not being defined.
|
||||
return false;
|
||||
}
|
||||
|
||||
if ($reserved) {
|
||||
$value = str_replace($this->reservedEncoded, $this->reserved, $value);
|
||||
}
|
||||
|
||||
// If we do not need to include the key name, we just return the raw
|
||||
// value.
|
||||
if (!$combine || $skip_final_combine) {
|
||||
return $value;
|
||||
}
|
||||
|
||||
// Else we combine the key name: foo=bar, if value is not the empty string.
|
||||
return $key . ($value != '' || $combine_on_empty ? $combine . $value : '');
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the type of a passed in value
|
||||
*/
|
||||
private function getDataType($data)
|
||||
{
|
||||
if (is_array($data)) {
|
||||
reset($data);
|
||||
if (key($data) !== 0) {
|
||||
return self::TYPE_MAP;
|
||||
}
|
||||
return self::TYPE_LIST;
|
||||
}
|
||||
return self::TYPE_SCALAR;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function that merges multiple combine calls
|
||||
* for multi-key templates.
|
||||
*/
|
||||
private function combineList(
|
||||
$vars,
|
||||
$sep,
|
||||
$parameters,
|
||||
$combine,
|
||||
$reserved,
|
||||
$tag_empty,
|
||||
$combine_on_empty
|
||||
) {
|
||||
$ret = array();
|
||||
foreach ($vars as $var) {
|
||||
$response = $this->combine(
|
||||
$var,
|
||||
$parameters,
|
||||
$sep,
|
||||
$combine,
|
||||
$reserved,
|
||||
$tag_empty,
|
||||
$combine_on_empty
|
||||
);
|
||||
if ($response === false) {
|
||||
continue;
|
||||
}
|
||||
$ret[] = $response;
|
||||
}
|
||||
return implode($sep, $ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to encode and trim values
|
||||
*/
|
||||
private function getValue($value, $length)
|
||||
{
|
||||
if ($length) {
|
||||
$value = substr($value, 0, $length);
|
||||
}
|
||||
$value = rawurlencode($value);
|
||||
return $value;
|
||||
}
|
||||
}
|
||||
42
src/aliases.php
Normal file
42
src/aliases.php
Normal file
@ -0,0 +1,42 @@
|
||||
<?php
|
||||
|
||||
if (class_exists('Google_Client')) {
|
||||
// Prevent error with preloading in PHP 7.4
|
||||
// @see https://github.com/googleapis/google-api-php-client/issues/1976
|
||||
return;
|
||||
}
|
||||
|
||||
$classMap = [
|
||||
'Google\\Client' => 'Google_Client',
|
||||
'Google\\Service' => 'Google_Service',
|
||||
'Google\\AccessToken\\Revoke' => 'Google_AccessToken_Revoke',
|
||||
'Google\\AccessToken\\Verify' => 'Google_AccessToken_Verify',
|
||||
'Google\\Model' => 'Google_Model',
|
||||
'Google\\Utils\\UriTemplate' => 'Google_Utils_UriTemplate',
|
||||
'Google\\AuthHandler\\Guzzle6AuthHandler' => 'Google_AuthHandler_Guzzle6AuthHandler',
|
||||
'Google\\AuthHandler\\Guzzle7AuthHandler' => 'Google_AuthHandler_Guzzle7AuthHandler',
|
||||
'Google\\AuthHandler\\Guzzle5AuthHandler' => 'Google_AuthHandler_Guzzle5AuthHandler',
|
||||
'Google\\AuthHandler\\AuthHandlerFactory' => 'Google_AuthHandler_AuthHandlerFactory',
|
||||
'Google\\Http\\Batch' => 'Google_Http_Batch',
|
||||
'Google\\Http\\MediaFileUpload' => 'Google_Http_MediaFileUpload',
|
||||
'Google\\Http\\REST' => 'Google_Http_REST',
|
||||
'Google\\Task\\Retryable' => 'Google_Task_Retryable',
|
||||
'Google\\Task\\Exception' => 'Google_Task_Exception',
|
||||
'Google\\Task\\Runner' => 'Google_Task_Runner',
|
||||
'Google\\Collection' => 'Google_Collection',
|
||||
'Google\\Service\\Exception' => 'Google_Service_Exception',
|
||||
'Google\\Service\\Resource' => 'Google_Service_Resource',
|
||||
'Google\\Exception' => 'Google_Exception',
|
||||
];
|
||||
|
||||
foreach ($classMap as $class => $alias) {
|
||||
class_alias($class, $alias);
|
||||
}
|
||||
|
||||
/**
|
||||
* This class needs to be defined explicitly as scripts must be recognized by
|
||||
* the autoloader.
|
||||
*/
|
||||
class Google_Task_Composer extends \Google\Task\Composer
|
||||
{
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user