Como integrar a API do Planilhas Google com PHP
No passado, trabalhei em um projeto em que queríamos gravar dados dinamicamente na planilha do Google. Para isso, interagimos com a API Sheets. Achei um tópico interessante para a postagem do blog. Portanto, neste artigo, estudamos como integrar a API do Planilhas Google usando PHP. Vamos realizar operações de criação, gravação, acréscimo e leitura em planilhas por meio da API.
O Google Spreadsheet é um pacote de software gratuito baseado na web mantido pelo Google. Pode-se usar a planilha para seus próprios fins no serviço Google Drive.
Quando se trata de sites, você pode usar as planilhas do Google para vários fins. Pode-se armazenar as informações de contato do usuário (telefone e e-mail), detalhes de pagamento, registros de eventos, atividades e muito mais na planilha do Google. No site, você pode querer um sistema automatizado que faça todas as operações de leitura e gravação em planilhas quando uma ação específica for acionada. Isso pode ser feito por meio da API de planilhas.
Registrar um aplicativo e criar credenciais
Vou usar o OAuth para interagir com a API. OAuth é uma maneira mais segura e recomendada de fazer operações de API. Siga as etapas abaixo que são necessárias para a integração OAuth.
- Vá para o Google Developer Console https://console.developers.google.com
- Crie um novo projeto. Como alternativa, você também pode selecionar um projeto existente.
- Dê um nome ao seu projeto. O console do Google irá gerar um ID de projeto exclusivo para ele.
- Seu projeto aparecerá no topo da barra lateral esquerda.
- Clique em Biblioteca. Você verá uma lista de APIs do Google.
- Ative a API do Google Sheets.
- Clique nas credenciais. Selecione o ID do cliente Oauth em Criar credenciais. Escolha o botão de opção para Web Application.
- Dê o nome. Em Origens JavaScript autorizadas, insira o URL do seu domínio. Nos URIs de redirecionamento autorizados, adicione o link do URL de redirecionamento. No meu caso, passei o URL http: //localhost/google-sheets-api/callback.php
- Clique no botão Criar. Você obterá o ID do cliente e o segredo do cliente no pop-up. Copie esses detalhes. Vamos precisar disso em um momento.
Configuração básica
Como dito, usaremos OAuth para realizar as operações da API. Exige que você gere um token de acesso que atua como um identificador para sua conta. Usando esse token de acesso, as APIs do Google validam se a solicitação de entrada é válida e autorizada.
O token de acesso tem vida curta. Eles expiram em breve. E uma vez expirado, não podemos fazer chamadas de API, pois o Google trata a solicitação com o token expirado como uma solicitação não autorizada. Para resolver esse problema, usamos o ‘refresh_token’ para gerar novamente o token de acesso em segundo plano. É assim que o OAuth funciona.
Vamos começar a construir o fluxo OAuth. Crie o composer.jsonarquivo e adicione as linhas abaixo nele.
{
"require": {
"google/apiclient": "2.0",
"hybridauth/hybridauth": "~3.0"
}
}Em seguida, execute o comando abaixo para a instalação dessas bibliotecas.
composer installQuando geramos o token de acesso, ele precisa ser armazenado em um banco de dados. Ao armazená-lo, você pode buscar um token a qualquer momento e fazer chamadas de API. Execute a consulta abaixo para criar uma tabela no banco de dados.
CREATE TABLE `token` ( `id` int(11) NOT NULL AUTO_INCREMENT,
`access_token` text NOT NULL,
PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;Agora, crie uma classe de banco de dados que irá interagir com o banco de dados e recuperar, armazenar e atualizar as informações do token na tabela.
class-db.php
<?php
class DB {
private $dbHost = "DB_HOST";
private $dbUsername = "DB_USERNAME";
private $dbPassword = "DB_PASSWORD";
private $dbName = "DB_NAME";
public function __construct(){
if(!isset($this->db)){
// Connect to the database
$conn = new mysqli($this->dbHost, $this->dbUsername, $this->dbPassword, $this->dbName);
if($conn->connect_error){
die("Failed to connect with MySQL: ". $conn->connect_error);
}else{
$this->db = $conn;
}
}
}
public function is_table_empty() {
$result = $this->db->query("SELECT id FROM token");
if($result->num_rows) {
return false;
}
return true;
}
public function get_access_token() {
$sql = $this->db->query("SELECT access_token FROM token");
$result = $sql->fetch_assoc();
return json_decode($result['access_token']);
}
public function get_refersh_token() {
$result = $this->get_access_token();
return $result->refresh_token;
}
public function update_access_token($token) {
if($this->is_table_empty()) {
$this->db->query("INSERT INTO token(access_token) VALUES('$token')");
} else {
$this->db->query("UPDATE token SET access_token = '$token' WHERE id = (SELECT id FROM token)");
}
}
}Substitua os espaços reservados no código acima por suas credenciais de banco de dados reais. Estou supondo que você deseja usar uma única conta do Google. Se você pretende usar várias contas, modifique as consultas de acordo com seus requisitos.
Gerar token de acesso
Concluímos a criação de uma mesa e a instalação de bibliotecas. A próxima coisa a fazer é autorizar a conta do Google e armazenar o token de acesso na tabela ‘token’.
Crie um config.phparquivo e escreva uma configuração de acordo com as diretrizes da biblioteca HybridAuth.
config.php
<?php
require_once 'vendor/autoload.php';
require_once 'class-db.php';
define('GOOGLE_CLIENT_ID', 'PASTE_CLIENT_ID_HERE');
define('GOOGLE_CLIENT_SECRET', 'PASTE_CLIENT_SECRET_HERE');
$config = [
'callback' => 'YOUR_DOMAIN_URL/callback.php',
'keys' => [
'id' => GOOGLE_CLIENT_ID,
'secret' => GOOGLE_CLIENT_SECRET
],
'scope' => 'https://www.googleapis.com/auth/spreadsheets',
'authorize_url_parameters' => [
'approval_prompt' => 'force', // to pass only when you need to acquire a new refresh token.
'access_type' => 'offline'
]
];
$adapter = new HybridauthProviderGoogle( $config );Certifique-se de definir os valores das constantes GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET. Além disso, passe o URL de retorno no código acima. Quando o usuário concluir a autorização, ele redirecionará para o URL de retorno de chamada.
Usando o callback.phparquivo, buscaremos os detalhes do token de acesso e os armazenaremos no banco de dados da seguinte maneira.
callback.php
<?php
require_once 'config.php';
try {
$adapter->authenticate();
$token = $adapter->getAccessToken();
$db = new DB();
if($db->is_table_empty()) {
$db->update_access_token(json_encode($token));
echo "Access token inserted successfully.";
}
}
catch( Exception $e ){
echo $e->getMessage() ;
}Neste estágio, vá para o navegador e execute YOUR_DOMAIN_URL / callback.php, ele irá redirecioná-lo para a conta do Google. Conclua o processo de autorização. Após concluir o processo, verifique a tabela de ‘tokens’. Ele deveria ter armazenado as informações do token.
Crie uma planilha usando Sheets API e PHP
Agora você armazenou o token de acesso em sua tabela. Isso significa que você pode prosseguir com as outras operações nas planilhas do Google de sua conta. Vamos primeiro começar criando uma planilha usando a API Sheets.
create-sheet.php
<?php
require_once 'config.php';
create_spreadsheet();
function create_spreadsheet() {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
$client->setAccessToken($accessToken);
$service = new Google_Service_Sheets($client);
try {
$spreadsheet = new Google_Service_Sheets_Spreadsheet([
'properties' => [
'title' => 'API Sheet'
]
]);
$spreadsheet = $service->spreadsheets->create($spreadsheet, [
'fields' => 'spreadsheetId'
]);
printf("Spreadsheet ID: %sn", $spreadsheet->spreadsheetId);
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
create_spreadsheet();
} else {
echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}Esse código primeiro obtém os detalhes do token do banco de dados. Usando esse token, ele chama o serviço de planilha do Google e cria uma planilha. Imprimi o ID de uma planilha criada.
Se um token de acesso expirar, o código vai para o bloco catch. No bloco catch, ele regenera o token de acesso, atualiza-o no banco de dados e continua a operação da API.
O mesmo código com pequenas alterações será usado para outras operações em planilhas.
Grave dados em uma planilha
Para realizar as operações de gravação, você precisa passar um intervalo de células a serem gravadas. Por exemplo, você deseja adicionar os títulos Nome e E-mail na parte superior. Nesse caso, seu intervalo se torna ‘A1: B1’. Isso significa que escreveremos os cabeçalhos de Nome e E-mail nas células A1 e B1, respectivamente.
<?php
require_once 'config.php';
write_to_sheet('SPREADSHEET_ID');
function write_to_sheet($spreadsheetId = '') {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
$client->setAccessToken($accessToken);
$service = new Google_Service_Sheets($client);
try {
$range = 'A1:B1';
$values = [
[
'Name',
'Email',
],
];
$body = new Google_Service_Sheets_ValueRange([
'values' => $values
]);
$params = [
'valueInputOption' => 'USER_ENTERED'
];
$result = $service->spreadsheets_values->update($spreadsheetId, $range, $body, $params);
printf("%d cells updated.", $result->getUpdatedCells());
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
write_to_sheet($spreadsheetId);
} else {
echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}Aqui, eu passei o ID da planilha para o método. Você pode modificar esta função e passar parâmetros adicionais. No código anterior, retornamos o ID da planilha que pode ser usado no código acima. Como alternativa, você pode obter o ID da planilha no URL da página. Veja a imagem abaixo.
A string que aparece entre ‘d’ e ‘editar’ é o ID de uma planilha do Google.
Anexar dados a uma planilha do Google
Se você deseja armazenar informações específicas na planilha do Google, precisa anexá-las à planilha existente. Pode haver casos em que você deseja anexar uma ou mais linhas de uma vez. O usuário pode passar um ou vários elementos da matriz e anexar dados à planilha, conforme mostrado abaixo.
<?php
require_once 'config.php';
append_to_sheet('SPREADSHEET_ID');
function append_to_sheet($spreadsheetId = '') {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
$client->setAccessToken($accessToken);
$service = new Google_Service_Sheets($client);
try {
$range = 'A1:B1';
$values = [
[
'John Doe',
'[email protected]',
],
[
'Jack Waugh',
'[email protected]',
],
// Additional rows ...
];
$body = new Google_Service_Sheets_ValueRange([
'values' => $values
]);
$params = [
'valueInputOption' => 'USER_ENTERED'
];
$result = $service->spreadsheets_values->append($spreadsheetId, $range, $body, $params);
printf("%d cells appended.", $result->getUpdates()->getUpdatedCells());
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
append_to_sheet($spreadsheetId);
} else {
echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}Usei o intervalo ‘A1: B1’ e passei 2 elementos de matriz separados. A API Sheets anexa esses detalhes após os dados da tabela. Observe que, embora estejamos passando ‘A1: B1’ no intervalo, isso não substituirá os valores já escritos nessas células. Em vez disso, ele grava dados nas próximas células disponíveis.
Leia os dados de uma planilha do Google
Escrevemos um código para criar uma planilha, escrever em uma planilha e anexar dados a ela. Finalmente, vamos ver como ler dados de uma planilha do Google.
<?php
require_once 'config.php';
read_sheet('SPREADSHEET_ID');
function read_sheet($spreadsheetId = '') {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
$client->setAccessToken($accessToken);
$service = new Google_Service_Sheets($client);
try {
$range = 'A:B';
$response = $service->spreadsheets_values->get($spreadsheetId, $range);
$values = $response->getValues();
if (empty($values)) {
print "No data found.n";
} else {
print "Name, Email:n";
foreach ($values as $row) {
// Print columns A and E, which correspond to indices 0 and 4.
printf("%s, %sn", $row[0], $row[1]);
}
}
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
read_sheet($spreadsheetId);
} else {
echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}Espero que você entenda como integrar a API do Planilhas Google usando PHP. Eu gostaria de ouvir seus pensamentos e sugestões na seção de comentários abaixo.
Artigos relacionados
- Como usar a API do YouTube para enviar vídeo ao canal do YouTube
- Como adicionar o login do Google OAuth a um site com PHP
- Como criar uma reunião com zoom usando API Zoom e PHP