April 2008
- Einführung
- Ruby abrufen und installieren
- Authentifizierung | Sheets API verwenden
- Arbeitsblätter abrufen
- Inhalte im listFeed veröffentlichen
- Inhalt mit Zellfeed aktualisieren
- Schlusswort
Einführung
Ruby ist eine dynamische Skriptsprache, die in den letzten Jahren aufgrund des beliebten Frameworks für die Webentwicklung viel Aufmerksamkeit erhalten hat. In diesem Artikel wird erläutert, wie Sie Ruby zur Interaktion mit Google Data API-Diensten verwenden. Wir werden uns nicht auf die Bahnen konzentrieren, sondern vielmehr auf die Erklärung der zugrunde liegenden HTTP-Befehle und die Struktur unserer Feeds. All diese Beispiele können über die Befehlszeile mithilfe von irb, der interaktiven Shell von Ruby, aufgerufen werden.
Wie Sie vielleicht aus dem cURL-Artikel wissen, nutzen die Google Data APIs das Atom Publishing Protocol, um Webressourcen darzustellen, zu erstellen und zu aktualisieren. Das Schöne an diesem Protokoll ist, dass HTTP-Standardverben verwendet werden, um Anfragen zu formulieren, die mit Standard-HTTP-Statuscodes beantwortet werden.
Die Verben, die wir in diesem Artikel verwenden, lauten GET zum Abrufen von Inhalten, POST zum Hochladen neuer Inhalte und PUT zum Aktualisieren vorhandener Inhalte. Einige der Standardcodes, die Sie möglicherweise über die Google Data APIs sehen, sind 200 für den Erfolg beim Abrufen eines Feeds oder Eintrags oder 201 für die erfolgreiche Erstellung oder Aktualisierung einer Ressource. Wenn ein Fehler auftritt, z. B. wenn eine fehlerhafte Anfrage gesendet wird, wird ein 400-Code (Bad-Request) zurückgegeben. Im Antworttext finden Sie eine detailliertere Nachricht mit einer Erklärung, was genau schiefgelaufen ist.
Ruby bietet als Teil des Moduls „Netto“ eine schöne Debugging-Option. Zum besseren Verständnis dieser Codebeispiele habe ich sie hier jedoch nicht aktiviert.
Ruby abrufen und installieren
Ruby kann unter Linux mit den meisten Paketverwaltungssystemen installiert werden. Informationen zu anderen Betriebssystemen und zum Abrufen des vollständigen Quellcodes finden Sie unter http://www.ruby-lang.org/en/downloads/. Ib, die interaktive Shell, die wir für diese Beispiele verwenden, sollte standardmäßig installiert werden. Um den hier aufgeführten Codebeispielen zu folgen, müssen Sie auch XmlSimple, eine kleine Bibliothek zum Parsen von XML in Ruby-Datenstrukturen, installieren. XMLSimple erhalten Sie unter http://xml-simple.rubyforge.org.
Sobald eine Ruby-Kopie auf Ihrem Computer ausgeführt wird, können Sie mit dem Paket Net:HTTP grundlegende Anfragen an die Datendienste von Google stellen. Das folgende Snippet zeigt, wie Sie die erforderlichen Importe aus der interaktiven Shell von Ruby ausführen. Wir fordern daher das Paket „net/http“ an, analysieren die URL für den Videofeed mit den besten Bewertungen von YouTube und führen dann eine HTTP-GET-Anfrage aus.
irb(main):001:0> require 'net/http' => true irb(main):002:0> youtube_top_rated_videos_feed_uri = \ 'http://gdata.youtube.com/feeds/api/standardfeeds/top_rated' => "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated" irb(main):003:0> uri = \ URI.parse(youtube_top_rated_videos_feed_uri) => #<URI::HTTP:0xfbf826e4 URL:http://gdata.youtube.com/feeds/api/standardfeeds/top_rated> irb(main):004:0> uri.host => "gdata.youtube.com" irb(main):005:0> Net::HTTP.start(uri.host, uri.port) do |http| irb(main):006:1* puts http.get(uri.path) irb(main):007:1> end #<Net::HTTPOK:0xf7ef22cc>
Diese Anfrage sollte ziemlich viel XML an die Befehlszeile ausgegeben haben. Sie haben möglicherweise bemerkt, dass sich alle Artikel in einem <feed>-Element befinden und als <entry>-Elemente bezeichnet werden. Wir brauchen uns noch keine Gedanken über die XML-Formatierung zu machen. Ich wollte euch nur erklären, wie ihr eine einfache Google Data API-Anfrage mit HTTP sendet. Wir werden die APIs jetzt umstellen und uns auf Tabellen konzentrieren, da die Informationen, die wir senden und abrufen können, eher Befehlszeilen sind.
Authentifizierung | Google Tabellen-API verwenden
Wir beginnen wieder mit dem Abrufen eines Feeds mit Eintragelementen. Dieses Mal möchten wir jedoch mit eigenen Tabellen arbeiten. Dazu müssen Sie sich zuerst beim Google-Konto-Dienst authentifizieren.
Wie Sie vielleicht aus der Dokumentation zur GData-Authentifizierung kennen, gibt es zwei Möglichkeiten zur Authentifizierung bei Google-Diensten. AuthSub ist für webbasierte Anwendungen gedacht und beinhaltet einen Umtausch von Tokens. Der große Vorteil von AuthSub besteht darin, dass Ihre Anwendung keine Anmeldedaten speichern muss. ClientLogin ist für "installierte" Anwendungen gedacht. Während des ClientLogin-Prozesses werden Nutzername und Passwort über https zusammen mit einem String, der den gewünschten Dienst identifiziert, an die Google-Dienste gesendet. Der Google Sheets API-Dienst ist durch den String wise gekennzeichnet.
Wir kehren zur interaktiven Shell zurück. Authentifizieren Sie sich nun bei Google. Beachten Sie, dass wir HTTPS verwenden, um unsere Authentifizierungsanfrage und Anmeldedaten zu senden:
irb(main):008:0> require 'net/https'
=> true
irb(main):009:0> http = Net::HTTP.new('www.google.com', 443)
=> #<Net::HTTP www.google.com:443 open=false>
irb(main):010:0> http.use_ssl = true
=> true
irb(main):011:0> path = '/accounts/ClientLogin'
=> "/accounts/ClientLogin"
# Now we are passing in our actual authentication data.
# Please visit OAuth For Installed Apps for more information
# about the accountType parameter
irb(main):014:0> data = \
irb(main):015:0* 'accountType=HOSTED_OR_GOOGLE&Email=your email' \
irb(main):016:0* '&Passwd=your password' \
irb(main):017:0* '&service=wise'
=> accountType=HOSTED_OR_GOOGLE&Email=your email&Passwd=your password&service=wise"
# Set up a hash for the headers
irb(main):018:0> headers = \
irb(main):019:0* { 'Content-Type' => 'application/x-www-form-urlencoded'}
=> {"Content-Type"=>"application/x-www-form-urlencoded"}
# Post the request and print out the response to retrieve our authentication token
irb(main):020:0> resp, data = http.post(path, data, headers)
warning: peer certificate won't be verified in this SSL session
=> [#<Net::HTTPOK 200 OK readbody=true>, "SID=DQAAAIIAAADgV7j4F-QVQjnxdDRjpslHKC3M ... [ snipping out the rest of the authentication strings ]
# Strip out our actual token (Auth) and store it
irb(main):021:0> cl_string = data[/Auth=(.*)/, 1]
=> "DQAAAIUAAADzL... [ snip ]
# Build our headers hash and add the authorization token
irb(main):022:0> headers["Authorization"] = "GoogleLogin auth=#{cl_string}"
=> "GoogleLogin auth=DQAAAIUAAADzL... [ snip ]
OK Nachdem wir nun authentifiziert sind, versuchen wir, unsere eigenen Tabellen über eine Anfrage
http://spreadsheets.google.com/feeds/spreadsheets/private/full
Da es sich um eine authentifizierte Anfrage handelt, möchten wir auch unsere Header übergeben. Da wir mehrere Anfragen für verschiedene Feeds stellen werden, könnten wir diese Funktion auch in einer einfachen Funktion zusammenfassen, die wir get_feed nennen.
# Store the URI to the feed since we may want to use it again
irb(main):023:0> spreadsheets_uri = \
irb(main):024:0* 'http://spreadsheets.google.com/feeds/spreadsheets/private/full'
# Create a simple method to obtain a feed
irb(main):025:0> def get_feed(uri, headers=nil)
irb(main):026:1> uri = URI.parse(uri)
irb(main):027:1> Net::HTTP.start(uri.host, uri.port) do |http|
irb(main):028:2* return http.get(uri.path, headers)
irb(main):029:2> end
irb(main):030:1> end
=> nil
# Lets make a request and store the response in 'my_spreadsheets'
irb(main):031:0> my_spreadsheets = get_feed(spreadsheets_uri, headers)
=> #<Net::HTTPOK 200 OK readbody=true>
irb(main):032:0> my_spreadsheets
=> #<Net::HTTPOK 200 OK readbody=true>
# Examine our XML (showing only an excerpt here...)
irb(main):033:0> my_spreadsheets.body
=> "<?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>http://spreadsheets.google.com/feeds/spreadsheets/private/full</id><updated>2008-03-20T20:49:39.211Z</updated>
<category scheme='http://schemas.google.com/spreadsheets/2006' term='http://schemas.google.com/spreadsheets/2006#spreadsheet'/>
<title type='text'>Available Spreadsheets - test.api.jhartmann@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='http://spreadsheets.google.com/feeds/spreadsheets/private/full'/><link rel='self' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/spreadsheets/private/full?tfe='/>
<openSearch:totalResults>6</openSearch:totalResults><openSearch:startIndex>1</openSearch:startIndex><entry>
<id>http://spreadsheets.google.com/feeds/spreadsheets/private/full/o04927555739056712307.4365563854844943790</id><updated>2008-03-19T20:44:41.055Z</updated><category scheme='http://schemas.google.com/spreadsheets/2006' term='http://schemas.google.com/spreadsheets/2006#spreadsheet'/><title type='text'>test02</title><content type='text'>test02</content><link rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/worksheets/o04927555739056712307.4365563854844943790/private/full'/><link rel='alternate' type='text/html' href='http://spreadsheets.google.com/ccc?key=o04927555739056712307.4365563854844943790'/><link rel='self' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/spreadsheets/private/full/o04927555739056712307.4365563854844943790'/><author><name>test.api.jhartmann</name><email>test.api.jhartmann@gmail.com</email></author></entry><entry> ...
Wie gesagt, wir haben eine Menge XML-Code, den ich oben hervorgehoben habe, da Sie ihn nicht über die Befehlszeile entschlüsseln müssen. Um dies nutzerfreundlicher zu gestalten, lassen Sie es stattdessen mit XmlSimple in eine Datenstruktur parsen:
# Perform imports
irb(main):034:0> require 'rubygems'
=> true
irb(main):035:0> require 'xmlsimple'
=> true
irb(main):036:0> doc = \
irb(main):037:0* XmlSimple.xml_in(my_spreadsheets.body, 'KeyAttr' => 'name')
# Import the 'pp' module for 'pretty printing'
irb(main):038:0> require 'pp'
=> true
# 'Pretty-print' our XML document
irb(main):039:0> pp doc
{"totalResults"=>["6"],
"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#spreadsheet",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>
[{"type"=>"text",
"content"=>"Available Spreadsheets - Test-account"}],
"startIndex"=>["1"],
"id"=>["http://spreadsheets.google.com/feeds/spreadsheets/private/full"],
"entry"=>
[{"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#spreadsheet",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>[{"type"=>"text", "content"=>"blank"}],
"author"=>
[{"name"=>["Test-account"],
"email"=>["my email"]}],
"id"=>
["http://spreadsheets.google.com/feeds/spreadsheets/private/full/o04927555739056712307.3387874275736238738"],
"content"=>{"type"=>"text", "content"=>"blank"},
"link"=>
[ snipping out the rest of the XML ]
Arbeitsblätter erhalten
Wie Sie der obigen Ausgabe entnehmen können, enthält mein Feed 6 Tabellen. Um diesen Artikel kurz zu halten, habe ich die restliche XML-Ausgabe (und die meisten anderen Einträge) abgeschnitten. Um diese Tabelle genauer zu untersuchen, sind einige weitere Schritte erforderlich:
- Tabellenschlüssel abrufen
- Verwende den Tabellenschlüssel, um unseren Arbeitsblatt-Feed zu erhalten.
- Rufen Sie die ID für das Arbeitsblatt ab, das Sie verwenden möchten.
- Fordern Sie entweder Zellfeed oder listFeed an, um auf den Inhalt des Arbeitsblatts zuzugreifen.
Das klingt zwar nach viel Arbeit, aber ich zeige Ihnen, dass es ganz einfach ist, wenn wir ein paar einfache Methoden schreiben. "cellFeed" und "listFeed" sind zwei unterschiedliche Darstellungen für die Zelleninhalte eines Arbeitsblatts. Der „listFeed“ stellt eine ganze Zeile mit Informationen dar und wird zum Posten neuer Daten empfohlen. Der Zellfeed steht für einzelne Zellen und wird entweder für einzelne Zellenaktualisierungen oder für Batch-Updates für viele einzelne Zellen genutzt (beide mit PUT). Weitere Informationen finden Sie in der Dokumentation zur Google Sheets API.
Zuerst müssen wir den Tabellenschlüssel extrahieren (oben in der XML-Ausgabe markiert), um dann den Arbeitsblatt-Feed zu erhalten:
# Extract the spreadsheet key from our datastructure
irb(main):040:0> spreadsheet_key = \
irb(main):041:0* doc["entry"][0]["id"][0][/full\/(.*)/, 1]
=> "o04927555739056712307.3387874275736238738"
# Using our get_feed method, let's obtain the worksheet feed
irb(main):042:0> worksheet_feed_uri = \
irb(main):043:0* "http://spreadsheets.google.com/feeds/worksheets/#{spreadsheet_key}/private/full"
=> "http://spreadsheets.google.com/feeds/worksheets/o04927555739056712307.3387874275736238738/private/full"
irb(main):044:0> worksheet_response = get_feed(worksheet_feed_uri, headers)
=> #<Net::HTTPOK 200 OK readbody=true>
# Parse the XML into a datastructure
irb(main):045:0> worksheet_data = \
irb(main):046:0* XmlSimple.xml_in(worksheet_response.body, 'KeyAttr' => 'name')
=> {"totalResults"=>["1"], "category"=>[{"term ... [ snip ]
# And pretty-print it
irb(main):047:0> pp worksheet_data
{"totalResults"=>["1"],
"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#worksheet",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>[{"type"=>"text", "content"=>"blank"}],
"author"=>
[{"name"=>["test.api.jhartmann"],
"email"=>["test.api.jhartmann@gmail.com"]}],
"startIndex"=>["1"],
"id"=>
["http://spreadsheets.google.com/feeds/worksheets/o04927555739056712307.3387874275736238738/private/full"],
"entry"=>
[{"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#worksheet",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>[{"type"=>"text", "content"=>"Sheet 1"}],
"rowCount"=>["100"],
"colCount"=>["20"],
"id"=>
["http://spreadsheets.google.com/feeds/worksheets/o04927555739056712307.3387874275736238738/private/full/od6"],
"content"=>{"type"=>"text", "content"=>"Sheet 1"},
"link"=>
[{"href"=>
"http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full",
"rel"=>"http://schemas.google.com/spreadsheets/2006#listfeed",
"type"=>"application/atom+xml"},
{"href"=>
"http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full",
"rel"=>"http://schemas.google.com/spreadsheets/2006#cellsfeed",
"type"=>"application/atom+xml"},
[ snip: cutting off the rest of the XML ]
Wie Sie sehen, finden wir jetzt die Links (highlighted above) für den Zugriff auf „listFeed“ und „cellFeed“. Bevor wir uns mit dem listFeed befassen, möchte ich kurz erklären, welche Daten derzeit in unserer Beispieltabelle vorhanden sind, damit Sie wissen, wonach wir suchen:
Unsere Tabelle ist sehr einfach aufgebaut und sieht in etwa so aus:
| language | website |
|---|---|
| Java | http://java.com |
| php | http://php.net |
Und so sehen diese Daten im listFeed aus:
irb(main):048:0> listfeed_uri = \
irb(main):049:0* worksheet_data["entry"][0]["link"][0]["href"]
=> "http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full"
irb(main):050:0> response = get_feed(listfeed_uri, headers)
=> #<Net::HTTPOK 200 OK readbody=true>
irb(main):051:0> listfeed_doc = \
irb(main):052:0* XmlSimple.xml_in(response.body, 'KeyAttr' => 'name')
=> {"totalResults"=>["2"], "category"=>[{"term" ... [ snip ]
# Again we parse the XML and then pretty print it
irb(main):053:0> pp listfeed_doc
{"totalResults"=>["2"],
"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#list",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>[{"type"=>"text", "content"=>"Programming language links"}],
"author"=>
[{"name"=>["test.api.jhartmann"],
"email"=>["test.api.jhartmann@gmail.com"]}],
"startIndex"=>["1"],
"id"=>
["http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full"],
"entry"=>
[{"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#list",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"language"=>["java"],
"title"=>[{"type"=>"text", "content"=>"ruby"}],
"website"=>["http://java.com"],
"id"=>
["http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca"],
"content"=>
{"type"=>"text", "content"=>"website: http://java.com"},
"link"=>
[{"href"=>
"http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca",
"rel"=>"self",
"type"=>"application/atom+xml"},
{"href"=>
"http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca/1j81anl6096",
"rel"=>"edit",
"type"=>"application/atom+xml"}],
"updated"=>["2008-03-20T22:19:51.739Z"]},
{"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#list",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"language"=>["php"],
"title"=>[{"type"=>"text", "content"=>"php"}],
"website"=>["http://php.net"],
"id"=>
["http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cokwr"],
"content"=>{"type"=>"text", "content"=>"website: http://php.net"},
[ snip ]
Wie Sie sehen, gibt listFeed den Inhalt Ihres Arbeitsblattes zurück. Dazu erstellt er für jede Zeile einen Eintrag. Es wird davon ausgegangen, dass die erste Zeile der Tabelle die Zellenüberschriften enthält und die XML-Header basierend auf den Daten in dieser Zeile dynamisch erstellt werden. Eine genauere Erläuterung bietet auch der eigentliche XML-Code:
<?xml version='1.0' encoding='UTF-8'?><feed [ snip namespaces ]> <id>http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full</id> <updated>2008-03-20T22:19:51.739Z</updated> <category scheme='http://schemas.google.com/spreadsheets/2006' term='http://schemas.google.com/spreadsheets/2006#list'/> <title type='text'>Programming language links</title> [ snip: cutting out links and author information ] <entry> <id>http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca</id> [ snip: updated and category ] <title type='text'>java</title> <content type='text'>website: http://java.com</content> <link rel='self' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca'/> <link rel='edit' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cn6ca/1j81anl6096'/> <gsx:language>java</gsx:language> <gsx:website>http://java.com</gsx:website> </entry> <entry> <id>http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cokwr</id> [ snip: updated and category ] <title type='text'>php</title> <content type='text'>website: http://php.net</content> <link rel='self' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cokwr'/> <link rel='edit' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full/cokwr/41677fi0nc'/> <gsx:language>php</gsx:language> <gsx:website>http://php.net</gsx:website> </entry> </feed>
Sehen wir uns für einen kurzen Vergleich an, wie die Informationen im Zellenfeed dargestellt werden:
# Extract the cellfeed link
irb(main):054:0> cellfeed_uri = \
irb(main):055:0* worksheet_data["entry"][0]["link"][1]["href"]
=> "http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full"
irb(main):056:0> response = \
irb(main):057:0* get_feed(cellfeed_uri, headers)
=> #<Net::HTTPOK 200 OK readbody=true>
# Parse into datastructure and print
irb(main):058:0> cellfeed_doc = \
irb(main):059:0* XmlSimple.xml_in(response.body, 'KeyAttr' => 'name')
=> {"totalResults"=>["6"], [ snip ]
irb(main):060:0> pp cellfeed_doc
{"totalResults"=>["6"],
"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#cell",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"title"=>[{"type"=>"text", "content"=>"Programming language links"}],
"rowCount"=>["101"],
"colCount"=>["20"],
"author"=>
[{"name"=>["test.api.jhartmann"],
"email"=>["test.api.jhartmann@gmail.com"]}],
"startIndex"=>["1"],
"id"=>
["http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full"],
"entry"=>
[{"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#cell",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"cell"=>
[{"col"=>"1",
"row"=>"1",
"content"=>"language",
"inputValue"=>"language"}],
"title"=>[{"type"=>"text", "content"=>"A1"}],
"id"=>
["http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R1C1"],
"content"=>{"type"=>"text", "content"=>"language"},
"link"=>
[{"href"=>
"http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R1C1",
"rel"=>"self",
"type"=>"application/atom+xml"},
{"href"=>
"http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R1C1/8srvbs",
"rel"=>"edit",
"type"=>"application/atom+xml"}],
"updated"=>["2008-03-20T22:19:51.739Z"]},
[ snip ]
Wie Sie sehen, werden 6 Einträge zurückgegeben, einer für jede Zelle. Abgesehen von dem Wert in Zelle A1, die das Wort „language“ enthält, wurde die gesamte Ausgabe abgeschnitten. Beachten Sie auch den oben angezeigten Link Bearbeiten. Dieser Link enthält einen Versionsstring (8srvbs) am Ende. Der Versionsstring ist wichtig, wenn Sie Zellendaten aktualisieren, wie wir am Ende dieses Artikels tun werden. Dadurch wird sichergestellt, dass Updates nicht überschrieben werden. Wenn Sie eine PUT-Anfrage zum Aktualisieren der Zellendaten senden, müssen Sie in Ihrer Anfrage den neuesten Versionsstring der Zelle angeben. Nach jedem Update wird ein neuer Versionsstring zurückgegeben.
Inhalte im listFeed veröffentlichen
Das erste Element, das wir zum Posten von Inhalten benötigen, ist der POST-Link für den listFeed. Dieser Link wird zurückgegeben, wenn der Listenfeed angefordert wird. Es enthält die URL http://schemas.google.com/g/2005#post als Wert für das Attribut rel. Dieses Linkelement muss geparst und das Attribut href extrahiert werden. Zuerst erstellen wir eine kleine Methode, um das Posten zu erleichtern:
irb(main):061:0> def post(uri, data, headers) irb(main):062:1> uri = URI.parse(uri) irb(main):063:1> http = Net::HTTP.new(uri.host, uri.port) irb(main):064:1> return http.post(uri.path, data, headers) irb(main):065:1> end => nil # Set up our POST url irb(main):066:0> post_url = \ irb(main):067:0* "http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full" => "http://spreadsheets.google.com/feeds/list/o04927555739056712307.3387874275736238738/od6/private/full" # We must use 'application/atom+xml' as MIME type so let's change our headers # which were still set to 'application/x-www-form-urlencoded' when we sent our # ClientLogin information over https irb(main):068:0> headers["Content-Type"] = "application/atom+xml" => "application/atom+xml" # Setting up our data to post, using proper namespaces irb(main):069:0> new_row = \ irb(main):070:0* '<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">' << irb(main):071:0* '<gsx:language xmlns:gsx="http://schemas.google.com/spreadsheets/2006/extended">' << irb(main):072:0* 'ruby</gsx:language>' << irb(main):073:0* '<gsx:website xmlns:gsx="http://schemas.google.com/spreadsheets/2006/extended">' << irb(main):074:0* 'http://ruby-lang.org</gsx:website>' << irb(main):075:0* '</atom:entry>' => "<atom:entry xmlns:atom=\"http://www.w3.org/2005/Atom\"><gsx:language ... [ snip ] # Performing the post irb(main):076:0> post_response = post(post_url, new_row, headers) => #<Net::HTTPCreated 201 Created readbody=true>
Der Status 201 gibt an, dass der Post erfolgreich war.
Contentfeed zum Aktualisieren von Inhalten verwenden
Aus der Dokumentation geht hervor, dass im Zellenfeed PUT-Anfragen auf vorhandenen Content bevorzugt werden. Aber da die Informationen, die wir zuvor aus dem Zellenfeed abgerufen haben, nur die Daten waren, die bereits in unserer eigentlichen Tabelle vorhanden waren, wie können wir neue Informationen hinzufügen? Wir müssen einfach für jede leere Zelle, in die wir Daten eingeben möchten, eine Anfrage stellen. Das folgende Snippet zeigt, wie die leere Zelle R5C1 (Zeile 5, Spalte 1) abgerufen wird, in die Sie Informationen zur Programmiersprache Python einfügen möchten.
Die ursprüngliche Variable cellfeed_uri enthielt nur den URI für den Zellfeed selbst. Wir möchten nun die Zelle anhängen, die bearbeitet werden soll, und den Versionsstring der Zelle abrufen, um sie zu bearbeiten:
# Set our query URI irb(main):077:0> cellfeed_query = cellfeed_uri + '/R5C1' => "http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1" # Request the information to extract the edit link irb(main):078:0> cellfeed_data = get_feed(cellfeed_query, headers) => #<Net::HTTPOK 200 OK readbody=true> irb(main):079:0> cellfeed_data.body => "<?xml version='1.0' encoding='UTF-8'?>
<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gs='http://schemas.google.com/spreadsheets/2006' xmlns:batch='http://schemas.google.com/gdata/batch'>
<id>http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1</id>
<updated>2008-03-24T21:55:36.462Z</updated>
<category scheme='http://schemas.google.com/spreadsheets/2006' term='http://schemas.google.com/spreadsheets/2006#cell'/>
<title type='text'>A5</title>
<content type='text'>
</content>
<link rel='self' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1'/>
<link rel='edit' type='application/atom+xml' href='http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1/47pc'/>
<gs:cell row='5' col='1' inputValue=''>
</gs:cell>
</entry>"
Wie Sie in der Codeliste oben sehen können, ist der Versionsstring 47pc. Möglicherweise müssen Sie ganz nach rechts scrollen. Um den Vorgang zu vereinfachen, erstellen wir eine Convenience-Methode, die den Versionsstring für jede Zelle abruft, die für uns interessant ist:
irb(main):080:0> def get_version_string(uri, headers=nil)
irb(main):081:1> response = get_feed(uri, headers)
irb(main):082:1> require 'rexml/document'
irb(main):083:1> xml = REXML::Document.new response.body
irb(main):084:1> edit_link = REXML::XPath.first(xml, '//[@rel="edit"]')
irb(main):085:1> edit_link_href = edit_link.attribute('href').to_s
irb(main):086:1> return edit_link_href.split(/\//)[10]
irb(main):087:1> end
=> nil
# A quick test
irb(main):088:0> puts get_version_string(cellfeed_query, headers)
47pc
=> nil
Währenddessen können wir ebenso eine Methode schreiben, um die PUT-Anfrage ebenfalls durchzuführen, oder noch besser, um eine Methode zur Durchführung der gesamten Batch-Aktualisierung zu schreiben. Wir verwenden ein Array mit Hashes mit den folgenden Variablen:
:batch_id: Eine eindeutige Kennung für jeden Teil der Batchanfrage.:cell_id: ID der Zelle, die im R#C#-Format aktualisiert werden soll, wobei Zelle A1 als R1C1 dargestellt wird.:data: Die Daten, die eingefügt werden sollen.
irb(main):088:0> def batch_update(batch_data, cellfeed_uri, headers)
irb(main):089:1> batch_uri = cellfeed_uri + '/batch'
irb(main):090:1> batch_request = <<FEED
irb(main):091:1" <?xml version="1.0" encoding="utf-8"?> \
irb(main):092:1" <feed xmlns="http://www.w3.org/2005/Atom" \
irb(main):093:1" xmlns:batch="http://schemas.google.com/gdata/batch" \
irb(main):094:1" xmlns:gs="http://schemas.google.com/spreadsheets/2006" \
irb(main):095:1" xmlns:gd="http://schemas.google.com/g/2005">
irb(main):096:1" <id>#{cellfeed_uri}</id>
irb(main):097:1" FEED
irb(main):098:1> batch_data.each do |batch_request_data|
irb(main):099:2* version_string = get_version_string(cellfeed_uri + '/' + batch_request_data[:cell_id], headers)
irb(main):100:2> data = batch_request_data[:data]
irb(main):101:2> batch_id = batch_request_data[:batch_id]
irb(main):102:2> cell_id = batch_request_data[:cell_id]
irb(main):103:2> row = batch_request_data[:cell_id][1,1]
irb(main):104:2> column = batch_request_data[:cell_id][3,1]
irb(main):105:2> edit_link = cellfeed_uri + '/' + cell_id + '/' + version_string
irb(main):106:2> batch_request<< <<ENTRY
irb(main):107:2" <entry>
irb(main):108:2" <gs:cell col="#{column}" inputValue="#{data}" row="#{row}"/>
irb(main):109:2" <batch:id>#{batch_id}</batch:id>
irb(main):110:2" <batch:operation type="update" />
irb(main):111:2" <id>#{cellfeed_uri}/#{cell_id}</id>
irb(main):112:2" <link href="#{edit_link}" rel="edit" type="application/atom+xml" />
irb(main):113:2" </entry>
irb(main):114:2" ENTRY
irb(main):115:2> end
irb(main):116:1> batch_request << '</feed>'
irb(main):117:1> return post(batch_uri, batch_request, headers)
irb(main):118:1> end
=> nil
# Our sample batch data to insert information about the Python programming language into our worksheet
irb(main):119:0> batch_data = [ \
irb(main):120:0* {:batch_id => 'A', :cell_id => 'R5C1', :data => 'Python'}, \
irb(main):121:0* {:batch_id => 'B', :cell_id => 'R5C2', :data => 'http://python.org' } ]
=> [{:cell_id=>"R5C1", :data=>"Python", :batch_id=>"A"}=>{:cell_id=>"R5C2", :data=>"http://python.org", :batch_id=>"B"}]
# Perform the update
irb(main):122:0> response = batch_update(batch_data, cellfeed_uri, headers)
=> #<Net::HTTPOK 200 OK readbody=true>
# Parse the response.body XML and print it
irb(main):123:0> response_xml = XmlSimple.xml_in(response.body, 'KeyAttr' => 'name')
=> [ snip ]
irb(main):124:0> pp response_xml
{"title"=>[{"type"=>"text", "content"=>"Batch Feed"}],
"xmlns:atom"=>"http://www.w3.org/2005/Atom",
"id"=>
["http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full"],
"entry"=>
[{"status"=>[{"code"=>"200", "reason"=>"Success"}],
"category"=>
[{"term"=>"http://schemas.google.com/spreadsheets/2006#cell",
"scheme"=>"http://schemas.google.com/spreadsheets/2006"}],
"cell"=>
[{"col"=>"1", "row"=>"5", "content"=>"Python", "inputValue"=>"Python"}],
"title"=>[{"type"=>"text", "content"=>"A5"}],
"id"=>
["http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1",
"A"],
"operation"=>[{"type"=>"update"}],
"content"=>{"type"=>"text", "content"=>"Python"},
"link"=>
[{"href"=>
"http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1",
"rel"=>"self",
"type"=>"application/atom+xml"},
{"href"=>
"http://spreadsheets.google.com/feeds/cells/o04927555739056712307.3387874275736238738/od6/private/full/R5C1/49kwzg",
"rel"=>"edit",
"type"=>"application/atom+xml"}],
"updated"=>["2008-03-27T15:48:48.470Z"]},
[ snip ]
Wie Sie sehen, war unsere Batchanfrage erfolgreich, da wir einen 200-OK-Antwortcode erhalten haben. Beim Parsen der Antwort-XML sehen wir, dass für jede einzelne :batch_id, die wir in unserem response_data-Array festlegen, eine separate Nachricht zurückgegeben wird. Weitere Informationen zur Batchverarbeitung finden Sie in der Dokumentation Batchverarbeitung in GData.
Fazit
Wie Sie sehen, ist es sehr einfach, die interaktive Shell von Ruby mit den Google Data APIs zu testen. Wir konnten sowohl über listFeed als auch Zellfeed auf unsere Tabellen und Arbeitsblätter zugreifen. Außerdem haben wir mithilfe einer POST-Anforderung neue Daten eingefügt und dann Methoden geschrieben, um eine Batch-Aktualisierung mit nur etwa 120 Codezeilen auszuführen. Von nun an sollte es nicht zu kompliziert sein, einige dieser einfachen Methoden in Klassen einzupacken und ein wiederverwendbares Framework zu erstellen.
Wenn Sie Fragen zur Verwendung dieser Tools mit Ihrer bevorzugten Google Data API haben, können Sie sich an den Diskussionsgruppen beteiligen.
Eine Klassendatei mit den oben beschriebenen Codebeispielen finden Sie unter http://code.google.com/p/google-data-samples-ruby.