Integrar os dados do Google Spreadsheets com PHP, Parte 1

Use PHP para processar e integrar alimentações de dados do Google Spreadsheets com um aplicativo da Web

O Google Spreadsheets é um conhecido aplicativo de planilha baseado na nuvem. Os desenvolvedores de aplicativos da Web conseguem acessar e procurar dados em planilhas on-line por meio da API de Dados do Google Spreadsheets. Este artigo apresenta a API de Dados do Google Spreadsheets e a demonstra no contexto de um aplicativo PHP, explicando como procurar e recuperar diferentes elementos do conteúdo da planilha.

Introdução

Acrônimos usados frequentemente

  • API: Interface de programa de aplicativo
  • HTML: Linguagem de Marcação de Hipertexto
  • HTTP: Protocolo de transporte de Hipertexto
  • URL: Localizador Uniforme de Recursos
  • XML: Linguagem de Marcação Extensível

Como a maioria das pessoas, eu uso muito as planilhas. Elas são boas para controlar o saldo de um talão de cheques, preparar um orçamento mensal e fazer uma estimativa e controle de programação de projeto. Mas há cerca de um ano, eu passei a usar o Google Spreadsheets em vez de um aplicativo de planilha instalado localmente. O Google Spreadsheets é um serviço baseado na nuvem que oferece suporte a todos os recursos de planilha que eu costumo usar. Essa mudança me deu duas vantagens principais:

  • Posso acessar remotamente os dados das minhas planilhas.
  • É muito mais fácil compartilhar e permitir a edição colaborativa do que ao usar um aplicativo instalado localmente.

O que torna o Google Spreadsheets especialmente interessante, da perspectiva do desenvolvedor, é que ele fornece uma API de Dados que permite aos desenvolvedores criar facilmente novos aplicativos ao redor dos dados da planilha de espaço do usuário. É possível acessar essa API por meio de qualquer kit de ferramentas de desenvolvimento com recursos XML, a Google fornece bibliotecas de cliente para as tecnologias PHP e Java™ .

Neste artigo de duas partes, apresento a API de Dados do Google Spreadsheets e mostro como integrar e usar dados da planilha a partir da nuvem com um aplicativo PHP. Neste primeiro artigo, apresento várias alimentações suportadas pela API de dados e ilustro como ler dados dessas alimentações usando a biblioteca de cliente PHP.


Entendendo as alimentações do Google Spreadsheets

Antes de entrar no código PHP, é preciso entender como funciona a API de dados do Google Spreadsheets. A API aceita solicitações de HTTP que contêm um ou mais argumentos de entrada e retorna um feed Atom que contém as informações solicitadas.

A API de Dados do Google Spreadsheets disponibiliza diversas alimentações. Repare que, para alguma dessas alimentações, é preciso o ID da planilha eletrônica (ssid) ou da planilha interna (wsid) para formular a URL de alimentação.

  • A alimentação das planilhas eletrônicas contém uma lista de planilhas eletrônicas disponíveis ao usuário. Pode ser acessada pela URL: https://spreadsheets.google.com/feeds/spreadsheets/private/full
  • A alimentação da planilha interna está ligada a uma planilha eletrônica específica e contém uma lista das planilhas internas daquela planilha eletrônica. É acessível por uma URL como: https://spreadsheets.google.com/feeds/worksheets/<ssid>/private/full
  • As alimentações de lista e de célula estão ligadas a uma planilha interna específica e contêm as linhas e células que compõem aquela planilha interna. São acessíveis por URLs como: https://spreadsheets.google.com/feeds/list/<ssid>/<wsid>/private/full

A alimentação de planilha eletrônica está disponível apenas para usuários autenticados. As alimentações de planilhas eletrônicas, como alimentações de planilhas internas, listas e células, podem ser acessadas até mesmo sem autenticação, dependendo das configurações de segurança da planilha eletrônica correspondente. Por exemplo, é possível obter uma alimentação de lista ou de célula para planilhas eletrônicas publicamente visíveis sem autenticação.

A Listagem 1 demonstra a aparência de uma alimentação típica de planilha eletrônica.

Listagem 1. Exemplo de alimentação de planilha eletrônica
<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' 
  xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/'>
  <id>https://spreadsheets.google.com/feeds/spreadsheets/private/full</id>
  <updated>2010-11-05T17:11:33.703Z</updated>
  <category scheme='http://schemas.google.com/spreadsheets/2006'
    term='http://schemas.google.com/spreadsheets/2006#spreadsheet'/>
  <title type='text'>Available Spreadsheets - someuser@gmail.com
  </title>
  <link rel='alternate' type='text/html' href='http://docs.google.com'/>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/spreadsheets/private/full'/>
  <link rel='self' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/spreadsheets/private/full'/>
  <openSearch:totalResults>3</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>https://spreadsheets.google.com/feeds/spreadsheets/private/full/ssid</id>
    <updated>2010-11-04T07:24:42.388Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#spreadsheet'/>
    <title type='text'>Overtime Hours</title>
    <content type='text'>Overtime Hours</content>
    <link rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed' 
      type='application/atom+xml' 
      href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full'/>
    <link rel='alternate' type='text/html' 
      href='https://spreadsheets.google.com/ccc?key'/>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/spreadsheets/private/full/ssid'/>
    <author>
      <name>someuser</name>
      <email>someuser@gmail.com</email>
    </author>
  </entry>
  <entry>
  ...
  </entry>
</feed>

Toda alimentação de planilha começa com um elemento <feed> como elemento-raiz. O elemento <feed> encerra um ou mais elementos <entry>, cada um representando uma planilha eletrônica diferente. Cada <entry> contém mais detalhes, incluindo o título, última data de atualização e autor de cada planilha eletrônica.

Repare que cada <entry> também contém um elemento <link rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed' ...>. Esse elemento especifica a URL para a alimentação da planilha interna da planilha eletrônica e fornece um modo de drill down até o próximo nível de detalhes. Solicitar essa URL gera uma alimentação de planilha interna que contém informações sobre as planilhas internas da planilha eletrônica selecionada. A Listagem 2 tem um exemplo de uma alimentação de planilha interna desse tipo.

Listagem 2. Exemplo de alimentação de planilha
<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' 
  xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/' 
  xmlns:gs='http://schemas.google.com/spreadsheets/2006'>
  <id>https://spreadsheets.google.com/feeds/worksheets/ssid/private/full</id>
  <updated>2010-11-04T07:23:37.513Z</updated>
  <category scheme='http://schemas.google.com/spreadsheets/2006'
    term='http://schemas.google.com/spreadsheets/2006#worksheet'/>
  <title type='text'>Estimate: Home Renovation</title>
  <link rel='alternate' type='text/html' href='https://spreadsheets.google.com/ccc
    ?key=ssid'/>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full'/>
  <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full'/>
  <link rel='self' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full'/>
  <author>
    <name>vikram.melonfire</name>
    <email>someuser@gmail.com</email>
  </author>
  <openSearch:totalResults>7</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>https://spreadsheets.google.com/feeds/worksheets/ssid/private/full/wsid
    </id>
    <updated>2010-11-04T07:22:22.440Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#worksheet'/>
    <title type='text'>Living Room</title>
    <content type='text'>Living Room</content>
    <link rel='http://schemas.google.com/spreadsheets/2006#listfeed' 
      type='application/atom+xml' href='https://spreadsheets.google.com/feeds/list/ssid/
      wsid/private/full'/>
    <link rel='http://schemas.google.com/spreadsheets/2006#cellsfeed' 
      type='application/atom+xml' href='https://spreadsheets.google.com/feeds/cells/ssid/
      wsid/private/full'/>
    <link rel='http://schemas.google.com/visualization/2008#visualizationApi' 
      type='application/atom+xml' href='https://spreadsheets.google.com/tq?
      key=ssid&sheet=wsid'/>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full/wsid'/>
    <link rel='edit' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/worksheets/ssid/private/full/wsid/key'
    />
    <gs:rowCount>100</gs:rowCount>
    <gs:colCount>20</gs:colCount>
  </entry>
  <entry>
  </entry>
</feed>

Dentro da alimentação de planilha, cada <entry> contém um conjunto de elementos <link>. Esses elementos especificam as URLs para a alimentação de lista da planilha interna, alimentação de célula, terminal de visualização e terminal de edição. Eles são úteis se for preciso visualizar ou editar as informações da planilha interna. Pode-se ver exemplos das alimentações de lista e de célula mais adiante neste artigo.


Recuperando as planilhas

As alimentações do Google Spreadsheets são codificadas em XML, e é bem fácil integrá-las a um aplicativo da Web em PHP. Um método é usar a extensão SimpleXML em PHP para analisar o feed Atom retornado pela API e extrair as informações relevantes dele. Mas por que fazer isso, quando o Zend Framework inclui a Zend_Gdata, uma biblioteca de cliente PHP projetada especificamente para desenvolvedores que tentam integrar aplicativos PHP à API de Dados do Google? Essa biblioteca, que pode ser baixada por download separadamente (consulte Recursos para obter o link), fornece uma interface conveniente e orientado a objetos para a API de Dados do Google, encapsulando a maioria das tarefas comuns, incluindo a autenticação, deixando-o livre para se concentrar nas função principais do seu aplicativo.

Após instalar a biblioteca GDat Zend, pode-se prosseguir para um exemplo de processamento de alimentação da API de Dados do Google Spreadsheets usando PHP. A Listagem 3 pega a alimentação da Listagem 1 e usa Zend_Gdata para extrair dela fragmentos relevantes de dados e formatá-los em uma página da Web. Repare que é preciso atualizar as credenciais do usuário no script com valores válidos antes de executá-las.

Listagem 3. Listagem de planilhas eletrônicas
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing spreadsheets</title>
    <style>
    body {
      font-family: Verdana;      
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get list of available spreadsheets
      $feed = $service->getSpreadsheetFeed();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }
    ?>
  
    <h2><?php echo $feed->title; ?></h2>
    <div>
    <?php echo $feed->totalResults; ?> spreadsheet(s) found.
    </div>  

    <ul>
    <?php foreach($feed as $entry): ?>
      <li class="name"><?php echo $entry->getTitle(); ?></li>
    <?php endforeach; ?>
    </ul>

  </body>
<html>

A Listagem 3 primeiro carrega as bibliotecas de classe Zend e, em seguida, inicializa uma instância da classe de serviço Zend_Gdata. Essa classe usa um objeto Zend_Http_Client, fornecido com as informações necessárias de autenticação do usuário e abre uma conexão autenticada com o serviço Google Spreadsheets. Após uma conexão de autenticação ser aberta, o método getSpreadsheetFeed() recupera a alimentação de planilha.

A resposta à chamada da API getSpreadsheetFeed() é um feed Atom similar ao da Listagem 1, , que é então analisada e convertida em um array de objetos Zend_Gdata_Spreadsheets_SpreadsheetEntry, cada um representando uma <entry> da alimentação. Agora é possível iterar no array, imprimindo o título de cada planilha eletrônica chamando o método correspondente getTitle() do objeto de entrada.

A Figura 1 ilustra a aparência da saída, com uma lista de três planilhas disponíveis (Horas Extras, Estimativa: Reforma da Casa e Vendas por Região).

Figura 1. Lista de planilhas de usuário
Lista de planilhas de usuário

Recuperando planilhas internas

Cada objeto Zend_Gdata_Spreadsheets_SpreadsheetEntry também expõe um método getWorksheets() , que acessa a alimentação da planilha interna da planilha eletrônica e retorna uma lista de planilhas internas como objetos Zend_Gdata_Spreadsheets_WorksheetEntry. Dê uma olhada na Listagem 4, que revisa a Listagem 3 e alista as planilhas internas de uma planilha eletrônica.

Listagem 4. Listagem de planilhas eletrônicas e planilhas internas
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing spreadsheets and worksheets</title>
    <style>
    body {
      font-family: Verdana;      
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get list of available spreadsheets
      $feed = $service->getSpreadsheetFeed();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }
    ?>

    <h2><?php echo $feed->title; ?></h2>
    <div>
    <?php echo $feed->totalResults; ?> spreadsheet(s) found.
    </div>  

    <ul>
    <?php foreach($feed as $entry): ?>
      <li class="name"><?php echo $entry->getTitle();  ?></li>
      <ul>
      <?php foreach($entry->getWorksheets() as $ws): ?>
        <li class="name"><?php echo $ws->getTitle(); ?></li>      
      <?php endforeach; ?>
      </ul>
    <?php endforeach; ?>
    </ul>

  </body>
<html>

Repare a chamada do método getWorksheets() de cada objeto de entrada. Esse método solicita a alimentação de planilha interna e converte o resultado em uma coleção de objetos Zend_Gdata_Spreadsheets_WorksheetEntry. Como antes, é fácil iterar por essa coleção e exibir o título de cada entrada de planilha interna usando seu método getTitle() . (Veja uma versão de somente texto da Figura 2.)

A Figura 2 ilustra a saída revisada.

Figura 2. Lista de planilhas eletrônica e planilhas internas de usuário
Lista de planilhas eletrônica e planilhas internas de usuário

Recuperando linhas da planilha interna

Agora que sabe como obter planilhas eletrônicas e planilhas internas, analise como pode recuperar o conteúdo real de uma planilha interna. O API de Dados do Google Spreadsheets oferece duas maneiras de fazer isso:

  • A alimentação de lista, que retorna uma alimentação que contém as linhas de uma planilha interna
  • A alimentação de célula, que retorna uma alimentação que contém as células individuais da planilha interna

Para ilustrar, considere a Figura 3, que mostra um exemplo de planilha interna da planilha de Vendas por Região. (A planilha mostra os setores e alista as vendas de cada seção por unidade e dólares.)

Figura 3. Planilha interna de exemplo usada neste artigo
Planilha interna de exemplo usada neste artigo

A Listagem 5 mostra a alimentação de lista correspondente dessa planilha interna.

Listagem 5. Alimentação de lista de exemplo
<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' 
  xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/'
  xmlns:gsx='http://schemas.google.com/spreadsheets/2006/extended'>
  <id>https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full</id>
  <updated>2010-11-04T07:21:19.158Z</updated>
  <category scheme='http://schemas.google.com/spreadsheets/2006'
    term='http://schemas.google.com/spreadsheets/2006#list'/>
  <title type='text'>North</title>
  <link rel='alternate' type='text/html' 
    href='https://spreadsheets.google.com/ccc?key=ssid'/>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full'/>
  <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full'/>
  <link rel='self' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full'/>
  <author>
    <name>someuser</name>
    <email>someuser@gmail.com</email>
  </author>
  <openSearch:totalResults>3</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/cokwr
    </id>
    <updated>2010-11-04T07:21:19.158Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#list'/>
    <title type='text'>Sector 1</title>
    <content type='text'>salesunits: 63274, sales: 2214590</content>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/cokwr'/>
    <link rel='edit' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/cokwr/
      2ed6e01i15gc7'/>
    <gsx:name>Sector 1</gsx:name>
    <gsx:salesunits>63274</gsx:salesunits>
    <gsx:sales>2214590</gsx:sales>
  </entry>
  <entry>
    <id>https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/cpzh4
    </id>
    <updated>2010-11-04T07:21:19.158Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#list'/>
    <title type='text'>Sector 2</title>
    <content type='text'>salesunits: 7263, sales: 254205</content>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/cpzh4'/>
    <link rel='edit' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/list/ssid/wsid/private/full/
      cpzh4/2ed58j9il57e0'/>
    <gsx:name>Sector 2</gsx:name>
    <gsx:salesunits>7263</gsx:salesunits>
    <gsx:sales>254205</gsx:sales>
  </entry>
  <entry>
  ...
  </entry>
</feed>

A Listagem 6 mostra a alimentação de célula dessa planilha interna.

Listagem 6. Alimentação de célula de exemplo
<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns='http://www.w3.org/2005/Atom' 
  xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/' 
  xmlns:gs='http://schemas.google.com/spreadsheets/2006' 
  xmlns:batch='http://schemas.google.com/gdata/batch'>
  <id>https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full</id>
  <updated>2010-11-04T07:20:36.606Z</updated>
  <category scheme='http://schemas.google.com/spreadsheets/2006'
    term='http://schemas.google.com/spreadsheets/2006#cell'/>
  <title type='text'>North</title>
  <link rel='alternate' type='text/html' 
    href='https://spreadsheets.google.com/ccc?key=ssid'/>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full'/>
  <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full'/>
  <link rel='http://schemas.google.com/g/2005#batch' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/batch'/>
  <link rel='self' type='application/atom+xml'
    href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full'/>
  <author>
    <name>vikram.melonfire</name>
    <email>someuser@gmail.com</email>
  </author>
  <openSearch:totalResults>12</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <gs:rowCount>100</gs:rowCount>
  <gs:colCount>20</gs:colCount>
  <entry>
    <id>https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C1
    </id>
    <updated>2010-11-04T07:20:36.606Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#cell'/>
    <title type='text'>A1</title>
    <content type='text'>Name</content>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C1'/>
    <link rel='edit' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C1/1fvl7'
    />
    <gs:cell row='1' col='1' inputValue='Name'>Name</gs:cell>
  </entry>
  <entry>
    <id>https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C2
    </id>
    <updated>2010-11-04T07:20:36.606Z</updated>
    <category scheme='http://schemas.google.com/spreadsheets/2006'
      term='http://schemas.google.com/spreadsheets/2006#cell'/>
    <title type='text'>B1</title>
    <content type='text'>Sales (Units)</content>
    <link rel='self' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C2'/>
    <link rel='edit' type='application/atom+xml'
      href='https://spreadsheets.google.com/feeds/cells/ssid/wsid/private/full/R1C2
      /rkxyni'/>
    <gs:cell row='1' col='2' inputValue='Sales (Units)'>Sales (Units)</gs:cell>
  </entry>
  <entry>
  ...
  </entry>
</feed>

A diferença entre a Listagem 5 e a Listagem 6 deve ser bem clara. A Listagem 5 representa cada linha da planilha de alimentação como uma entrada, enquanto a Listagem 6 representa cada célula da planilha interna como uma entrada. Dependendo de como deseja processar os dados da planilha, será preciso selecionar a alimentação adequada para seus propósitos.

A Listagem 7 ilustra como se pode recuperar e processar uma alimentação de lista usando Zend_Gdata. Repare que para essa listagem, e para as posteriores, será preciso atualizar o script com um ID de planilha eletrônica ou de planilha interna, ou ambas, substituindo as variáveis ssid e wsid do código de listagem por valores reais.

Listagem 7. Processando uma alimentação de lista
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing worksheet contents</title>
    <style>
    body {
      font-family: Verdana;      
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }    
    table, td {
      border: 1px solid black;
      vertical-align: top;
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get spreadsheet entry
      $ssEntry = $service->getSpreadsheetEntry(
        'https://spreadsheets.google.com/feeds/spreadsheets/ssid');
      
      // get worksheets in this spreadsheet
      $wsFeed = $ssEntry->getWorksheets();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }    
    ?>

    <h2><?php echo $ssEntry->title; ?></h2>

    <?php foreach($wsFeed as $wsEntry): ?>
    <div class="sheet">
      <div class="name">Worksheet: 
        <?php echo $wsEntry->getTitle(); ?></div>
      <table>
      <?php 
      // get list feed for worksheet
      // get individual entries in list
      $listFeed = $service->getListFeed($wsEntry); 
      foreach ($listFeed as $listEntry) {
        echo '<tr>';
        $rowData = $listEntry->getCustom();
        foreach($rowData as $customEntry) {
          echo '<td>' .  $customEntry->getText() . '</td>';
        }
        echo '</tr>';
      }
      ?>
      </table>
    </div>
    <?php endforeach; ?>

  </body>
<html>

A Listagem 7 usa o método getWorksheets() explicado na Listagem 4 para recuperar todas as planilhas internas da planilha eletrônica indicada como coleção de objetos Zend_Gdata_Spreadsheets_WorksheetEntry. O método getListFeed() do objeto de serviço é passado então para esses objetos de entrada, a fim de recuperar a alimentação de lista correspondente de cada planilha interna.

As linhas da planilha interna são representadas como objetos Zend_Gdata_Spreadsheets_ListEntry, cada um dos quais expõe um método getCustom() . Esse método retorna os elementos individuais (células) de cada linha como um array. Depois, é bem fácil iterar sobre esse array, imprimindo o conteúdo de cada célula em uma tabela.

A Figura 4 ilustra os resultados com planilhas internas individuais (Norte, Sul, Leste) que alistam unidades de vendas e dólares de setores individuais.

Figura 4. Conteúdo da planilha, recuperado de uma alimentação de lista
Conteúdo da planilha, recuperado de uma alimentação de lista

Recuperando células da planilha interna

Assim como é possível obter uma alimentação de lista usando o método getListFeed() de um objeto de serviço, também é possível obter uma alimentação de célula usando o método getCellFeed() . A Listagem 8 ilustra isso.

Listagem 8. Processando uma alimentação de célula
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing worksheet contents</title>
    <style>
    body {
      font-family: Verdana;      
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }    

    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get spreadsheet entry
      $ssEntry = $service->getSpreadsheetEntry(
        'https://spreadsheets.google.com/feeds/spreadsheets/ssid');

      // get worksheets in this spreadsheet
      $wsFeed = $ssEntry->getWorksheets();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }    
    ?>
  
    <h2><?php echo $ssEntry->title; ?></h2>

    <?php foreach($wsFeed as $wsEntry): ?>
    <div class="sheet">
      <div class="name">Worksheet: 
        <?php echo $wsEntry->getTitle(); ?></div>
      <table>
      <?php 
      // get cell feed for worksheet
      // display individual rows and columns from cell feed
      $cellFeed = $service->getCellFeed($wsEntry); 
      echo '<ul>';
      foreach ($cellFeed as $cellEntry) {
        $row = $cellEntry->getCell()->getRow();
        $column = $cellEntry->getCell()->getColumn();
        $value = $cellEntry->getCell()->getText();
        echo "<li>($row, $column) = $value</li>";
      }
      echo '</ul>';
      ?>
      </table>
    </div>
    <?php endforeach; ?>

  </body>
<html>

A Listagem 8 opera uma alimentação de célula, de modo que o método de extração de dados dela difere um pouco daquele mostrado na Listagem 7. Veja que, na Listagem 8, as células individuais da planilha interna são representadas como objetos Zend_Gdata_Spreadsheets_CellEntry, cada um dos quais expõem um método getCell() que retorna um objeto Cell. Esse objeto de célula, por sua vez, expõe métodos para retornar o número de linha, número de coluna e valor da célula correspondente. Agora, é bem fácil iterar sobre essa coleção e imprimir o conteúdo de cada célula em uma lista.

A Figura 5 ilustra a aparência da saída.

Figura 5. Conteúdo da planilha, recuperado de uma alimentação de célula
Conteúdo da planilha, recuperado de uma alimentação de célula

Recuperando dados de planilha interna como arrays

Zend_Gdata_Spreadsheets também vem com alguns métodos de atalho que convertem alimentações de lista e de célula em arrays PHP nativos para facilitar o processamento. Por exemplo, o método getContentsAsRows() recupera a alimentação de lista da planilha interna e a converte em um array PHP aninhado. A Listagem 9 ilustra isso.

Listagem 9. Processando um array de linhas de planilha interna
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing worksheet contents</title>
    <style>
    body {
      font-family: Verdana;      
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }    
    table, td {
      border: 1px solid black;
      vertical-align: top;
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get spreadsheet entry
      $ssEntry = $service->getSpreadsheetEntry(
        'https://spreadsheets.google.com/feeds/spreadsheets/ssid');
      
      // get worksheets in this spreadsheet
      $wsFeed = $ssEntry->getWorksheets();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }
    ?>
  
    <h2><?php echo $ssEntry->title; ?></h2>

    <?php foreach($wsFeed as $wsEntry): ?>
    <div class="sheet">
      <div class="name">Worksheet: 
        <?php echo $wsEntry->getTitle(); ?></div>
      <?php $rows = $wsEntry->getContentsAsRows(); ?>
      <table>
      <?php foreach ($rows as $row): ?>
        <tr>
          <?php foreach($row as $key => $value): ?>
          <td><?php echo $value; ?></td>
          <?php endforeach; ?>
        </tr>
      <?php endforeach; ?>
      </table>
    </div>
    <?php endforeach; ?>

  </body>
<html>

A Listagem 9 itera sobre uma coleção de objetos Zend_Gdata_Spreadsheets_WorksheetEntry retornados pelo método getWorksheets() e chama o método getContentsAsRows() de cada objeto de entrada para recuperar o conteúdo de cada linha da planilha interna como array aninhado. Cada linha é representada como array associativo de pares de valor de chave.

A Figura 6 exibe a saída.

Figura 6. Conteúdo da planilha, recuperado de um array de alimentação de lista
Conteúdo da planilha, recuperado de um array de alimentação de lista

Se os dados da célula forem mais comuns no seu trabalho, substitua a chamada de getContentsAsRows() por uma chamada de getContentsAsCells(), como na Listagem 10. Esse método retorna um array aninhado de dados de célula, com cada célula indexada por suas coordenadas de linha e coluna. A fórmula e valor final de cada célula também são incluídos no array aninhado.

Listagem 10. Processando um array de células de planilha interna
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Listing spreadsheet contents</title>
    <style>
    body {
      font-family: Verdana;      
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // get spreadsheet entry
      $ssEntry = $service->getSpreadsheetEntry(
        'https://spreadsheets.google.com/feeds/spreadsheets/ssid');

      // get worksheets in this spreadsheet
      $wsFeed = $ssEntry->getWorksheets();
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }
    ?>
  
    <h2><?php echo $ssEntry->title; ?></h2>

    <?php foreach($wsFeed as $wsEntry): ?>
    <div class="sheet">
      <div class="name">Worksheet: 
        <?php echo $wsEntry->getTitle(); ?></div>
      <?php $cells = $wsEntry->getContentsAsCells(); ?>
      <ul>
      <?php foreach ($cells as $location => $data): ?>
        <li>
          <?php echo $location; ?> = <?php echo $data['value']; ?>
          <?php echo ($data['formula'] != $data['value']) ? ' *' : ''; ?>
        </li>
      <?php endforeach; ?>
    </div>
    <?php endforeach; ?>

  </body>
<html>

A Figura 7 exibe os dados retornados pela Listagem 10. Se um valor de célula for gerado a partir de uma fórmula, esse valor será destacado com um asterisco. (Veja uma versão de somente texto da Figura 7.)

Figura 7. Conteúdo da planilha, recuperado de um array de alimentação de célula
Conteúdo da planilha, recuperado de um array de alimentação de célula

Filtrando dados da planilha interna

Também é possível filtrar o conteúdo de uma alimentação de lista ou de célula, de modo que ela retorne apenas as linhas ou células correspondentes aos critérios específicos. Para ilustrar, considere a Listagem 11que filtra a alimentação de lista para retornar apenas as entradas que mostrem mais de 25.000 unidades de vendas.

Listagem 11. Filtrando uma alimentação de lista de planilha interna
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Filtering worksheet contents</title>
    <style>
    body {
      font-family: Verdana;      
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }    
    table, td {
      border: 1px solid black;
      vertical-align: top;
    }
    </style>    
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // define worksheet query
      // get list feed for query
      $query = new Zend_Gdata_Spreadsheets_ListQuery();
      $query->setSpreadsheetKey('ssid');
      $query->setWorksheetId('wsid');
      $query->setSpreadsheetQuery('salesunits > 25000');
      $listFeed = $service->getListFeed($query);  
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    } 
    ?>
  
    <div class="sheet">
      <div class="name">Worksheet: 
        <?php echo $listFeed->getTitle(); ?></div>
      <table>
      <?php 
      foreach ($listFeed as $listEntry) {
        echo '<tr>';
        $rowData = $listEntry->getCustom();
        foreach($rowData as $customEntry) {
          echo '<td>' .  $customEntry->getText() . '</td>';
        }
        echo '</tr>';
      }
      ?>
      </table>
    </div>

  </body>
<html>

A Listagem 11 inicializa um objeto Zend_Gdata_Spreadsheets_ListQuery, que pode ser passado para o método getListFeed() do objeto de serviço como argumento adicional para filtrar os dados retornados na alimentação de lista. Esse objeto deve ser inicializado com as três entradas:

  • O ID da planilha eletrônica
  • O ID da planilha interna
  • Os critérios de filtro

O resultado é uma alimentação de lista que contém apenas as linhas de planilha interna que correspondem aos critérios de filtro.

Os critérios de filtro são especificados como nome de coluna, seguido por operador de igualdade, desigualdade ou booleano, seguido pelo valor de filtro. O Zend_Gdata codifica automaticamente a URL dos critérios de filtro ao transmitir a consulta para o servidor da API de Dados.

A Figura 8 ilustra o resultado.

Figura 8. Conteúdo da planilha, filtrado por unidades de vendas
Conteúdo da planilha, filtrado por unidades de vendas

De modo similar, é possível restringir os dados retornados em uma alimentação de célula, inicializando um objeto Zend_Gdata_Spreadsheets_CellQuery e passando esse objeto para o método getCellFeed() . Considere a Listagem 12, que demonstra a recuperação apenas da linha de cabeçalho da planilha interna especificada:

Listagem 12. Filtrando a alimentação de célula de uma planilha interna
<!DOCTYPE html 
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <title>Filtering worksheet contents</title>
    <style>
    body {
      font-family: Verdana;
    }
    div.sheet {
      margin: 10px;
      padding: 10px;
      border: silver 2px dotted;
    }
    div.name {
      color: red; 
      text-decoration: none;
      font-weight: bolder;  
    }
    table, td {
      border: 1px solid black;
      vertical-align: top;
    }
    </style>
  </head>
  <body>
    <?php
    // load Zend Gdata libraries
    require_once 'Zend/Loader.php';
    Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

    // set credentials for ClientLogin authentication
    $user = "someuser@gmail.com";
    $pass = "somepass";

    try {  
      // connect to API
      $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
      $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
      $service = new Zend_Gdata_Spreadsheets($client);

      // define worksheet query
      // get list feed for query
      $query = new Zend_Gdata_Spreadsheets_CellQuery();
      $query->setSpreadsheetKey('ssid');
      $query->setWorksheetId('wsid');
      $query->setMinRow(1);
      $query->setMaxRow(1);
      $cellFeed = $service->getCellFeed($query);
    } catch (Exception $e) {
      die('ERROR: ' . $e->getMessage());
    }
    ?>

    <div class="sheet">
      <div class="name">Worksheet: <?php echo $cellFeed->getTitle(); ?>
      </div>
      <table>
      <?php 
      echo '<tr>';
      foreach ($cellFeed as $cellEntry) {
        echo '<td>' .  $cellEntry->getCell()->getText() . '</td>';
      }
      echo '</tr>';
      ?>
      </table>
    </div>

  </body>
<html>

A Listagem 12 inicializa o Zend_Gdata_Spreadsheets_CellQuery e depois define um intervalo de células que deve ser retornado na alimentação, usando os métodos setMinRow(), setMaxRow(), setMinColumn()esetMaxColumn() do objeto de consulta. A alimentação resultante contém apenas as células do intervalo especificado. A Figura 9 ilustra o resultado.

Figura 9. Conteúdo da planilha, filtrado por número de linhas
Conteúdo da planilha, filtrado por número de linhas

Aplicativo de exemplo: visualizador de planilha baseado no navegador

Agora que sabemos as noções básicas de recuperação de dados a partir da API de Dados do Google Spreadsheets, vejamos um exemplo prático que coloca tudo no contexto. Esse próximo aplicativo usa uma combinação de PHP e JavaScript para apresentar a grade de dados que reflete o conteúdo de uma planilha interna on-line. Ele usa jQuery e jqGrid (consulte Recursos para obter os links de download) para gerar a grade de dados e o PHP para se conectar ao Google Spreadsheets, recuperar o conteúdo da planilha e formatá-lo em documento XML adequado para o consumo de jqGrid.

A Listagem 13 tem o código PHP que conecta à API de Dados do Google Spreadsheets, executa a consulta para obter a alimentação de lista da planilha e converte os dados resultantes em um formato XML de jqGrid.

Listagem 13. Recuperando e reformatando a alimentação de lista de uma planilha interna
<?php
// get page number from request
$page = $_GET['page']; 
if (empty($page)) {
  $page = 1;
}

// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');

// set credentials for ClientLogin authentication
$user = "someuser@gmail.com";
$pass = "somepass";

// set records per page
$recordsPerPage = 5;
$startIndex = (($page-1) * $recordsPerPage)+1;

try {
  // connect to API
  $service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
  $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
  $service = new Zend_Gdata_Spreadsheets($client);

  // get spreadsheet entry
  $query = new Zend_Gdata_Spreadsheets_ListQuery();
  $query->setSpreadsheetKey('ssid');
  $query->setWorksheetId('wsid');
  $query->setStartIndex($startIndex);
  $query->setMaxResults($recordsPerPage);
  $listFeed = $service->getListFeed($query); 
  $totalRecords = (string)$listFeed->getTotalResults()+0; // cast to integer

  // send XML headers
  header("Content-type: text/xml"); 
  echo "<?xml version='1.0'?" . ">\n";

  // send summary information
  echo '<rows>'; 
  echo '<page>' . $page . '</page>';
  echo '<total>' . ceil($totalRecords/$recordsPerPage) . '</total>';
  echo '<records>' . $totalRecords . '</records>';

  // send records
  foreach ($listFeed as $listEntry) {
    echo '<row>';
    $rowData = $listEntry->getCustom();
    foreach($rowData as $customEntry) {
      echo '<cell>' .  $customEntry->getText() . '</cell>';
    }
    echo '</row>';
  }
  echo '</rows>';
} catch (Exception $e) {
  die('ERROR: ' . $e->getMessage());
}    
?>

Observe que a Listagem 13 implementa um sistema simples de paginação, que espera um número da página na URL solicitada. Esse número da página é usado então para calcular a fatia de registros a ser retornada para a página atual, e os métodos setStartIndex() e setMaxResults() cuidam da configuração adequada da alimentação de lista.

A Figura 10 ilustra o formato XML retornado pela Listagem 13. (Veja uma versão de somente texto da Figura 10.)

Figura 10. Saída XML da Listagem 13
Saída XML da Listagem 13

O jqGrid lê esse formato XML e o converte em grade de dados, usando o código na Listagem 14.

Listagem 14. Exibindo uma planilha como grade de dados do lado do cliente
<html>
  <head>
    <link rel="stylesheet" type="text/css" media="screen"
      href="jquery-ui-1.8.6.custom.css" />
    <link rel="stylesheet" type="text/css" media="screen" href="ui.jqgrid.css" />
    <script src="jquery-1.4.2.min.js" type="text/javascript"></script>
    <script src="jquery.jqGrid.min.js" type="text/javascript"></script>  
    <script src="grid.locale-en.js" type="text/javascript"></script>
  </head>
  <body>
    <table id="list1">
    </table> 
    <div id="pager1">
    </div> 
    <script type="text/javascript">
    // code based on XML example at: http://www.trirand.com/blog/jqgrid/jqgrid.html
    jQuery().ready(function (){
      jQuery("#list1").jqGrid({
        url:'generate.php',
        datatype: "xml",
        colNames:
          ['Sector','Sales (Units)', 'Sales ($)'],
        colModel:
          [
            {name:'sector'},
            {name:'salesunits'},
            {name:'sales'},
          ],
        pager: jQuery('#pager1'),
        rowNum:5,
        autowidth: true,
        viewrecords: true,
      }).navGrid('#pager1',{edit:false,add:false,del:false})
      });
    </script>
  </body>
</html>

A Figura 11 ilustra a saída resultante (cada setor de uma região de vendas exibe suas vendas por unidade e dólares na planilha eletrônica).

Figura 11. Grade de dados do lado do cliente gerada a partir de uma alimentação de Google Spreadsheets
Grade de dados do lado do cliente gerada a partir de uma alimentação de Google Spreadsheets

Conclusão

Como esses exemplos ilustram, a API de Dados do Google Spreadsheets possibilita integrar facilmente dados do Google Spreadsheet diretamente em um aplicativo PHP. Este artigo se concentrou na recuperação de dados do Google Spreadsheets, ao apresentar-lhe os tipos básicos de alimentação disponíveis e ilustrar como usá-los com Zend_Gdata. Explicou como recuperar planilhas de usuário, examinar cada planilha para recuperar uma lista de planilhas internas disponíveis e depois usar as alimentações de lista e de célula para acessar o conteúdo real de uma planilha eletrônica. Apresentou também os conceitos básicos da filtragem de dados, explicando como exibir linhas e células de uma planilha que correspondam a critérios específicos ou a restrições de intervalo.

Mas isso não é tudo. Com a API de Dados do Google Spreadsheets, é possível visualizar dados de planilha a partir de um aplicativo PHP e alterá-los incluindo, editando e excluindo células, linhas e planilhas internas. A segunda parte deste artigo examinará esses aspectos da API de Dados do Google Spreadsheets em detalhes, então não deixe de dar uma olhada nesse artigo.

Recursos

Aprender

Obter produtos e tecnologias

  • Zend Framework: Transfira por download e construa aplicativos da Web 2.0 e serviços da Web mais seguros, confiáveis e modernos com APIs amplamente disponíveis.
  • jQuery: Obtenha a jQuery, uma biblioteca JavaScript rápida e concisa que simplifica a travessia de documentos HTML, manipulação de eventos, animação e interações Ajax para desenvolvimento rápido na Web.
  • jqGrid: Faça o download e teste esse controle Javascript ativado para Ajax que representa e manipula dados tabulares na Web.
  • versões de avaliação de produto IBM: Faça o download ou explore as versões de teste online no IBM SOA Sandbox e entre em contato com as ferramentas de desenvolvimento de aplicativos e produtos de middleware do DB2®, Lotus®, Rational®, Tivoli®e WebSphere®.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Cloud computing
ArticleID=657134
ArticleTitle=Integrar os dados do Google Spreadsheets com PHP, Parte 1
publish-date=07222011