Ta strona została przetłumaczona przez Cloud Translation API.

Korzystanie z Ruby za pomocą interfejsów API danych Google

Jochen Hartmann, zespół ds. interfejsów Google Data API
Kwiecień 2008 r.

Wprowadzenie
Pozyskiwanie i instalowanie Ruby
Uwierzytelnianie | Korzystanie z arkusza kalkulacyjnego API
Uzyskiwanie arkuszy kalkulacyjnych
Publikowanie treści w pliku danych list
Aktualizowanie treści za pomocą komórce
Podsumowanie

Wprowadzenie

Ruby to dynamiczny skrypt, który w ostatnich latach zyskał dużą uwagę ze względu na popularną platformę programistyczną online Rails. Z tego artykułu dowiesz się, jak używać Ruby do interakcji z usługami interfejsu API danych Google. Nie będziemy skupiać się na liniach kolejowych, ale lepiej wytłumaczymy podstawowe polecenia HTTP i strukturę naszych kanałów. Wszystkie podane tutaj przykłady można śledzić z poziomu wiersza poleceń, używając polecenia irb – interaktywnej powłoki Ruby.

Jak być może pamiętasz z artykułu cURL, interfejsy API danych Google używają protokołu Atom Publishing, by reprezentować, tworzyć i aktualizować zasoby internetowe. Korzyść z tego protokołu polega na tym, że standardowe czasowniki HTTP są używane do tworzenia żądań, w których przypadku stosowane są standardowe kody stanu HTTP.

Czasowniki, których użyjemy w tym artykule, to GET, aby pobrać nowe treści, POST – do przesyłania nowych treści i PUT – do aktualizowania istniejących treści. Niektóre ze standardowych kodów, które możesz napotkać przy użyciu interfejsów API danych Google, to 200 oznaczający pomyślne pobranie kanału lub wpisu albo 201 oznaczające pomyślne utworzenie lub zaktualizowanie zasobu. Jeśli coś pójdzie nie tak, na przykład otrzymasz żądanie nieprawidłowego formatu, zostanie zwrócony kod 400 (czyli „Nieprawidłowe żądanie”). W treści odpowiedzi znajdziesz bardziej szczegółową wiadomość z wyjaśnieniem, na czym dokładnie polega problem.

W module „Net” można korzystać z odpowiedniej opcji debugowania. Aby krótkie fragmenty kodu były wystarczająco krótkie, nie włączam ich tutaj.

Uzyskiwanie i instalowanie systemu Ruby

Jeśli używasz systemu Linux, możesz go zainstalować za pomocą większości systemów zarządzania pakietami. Aby uzyskać pełny kod źródłowy innych systemów operacyjnych, odwiedź stronę http://www.ruby-lang.org/en/downloads/. Irb, interaktywna powłoka, której będziemy używać w tych przykładach, powinna być zainstalowana domyślnie. Aby skorzystać z przedstawionych tutaj przykładów kodu, musisz też zainstalować XmlSimple – niewielką bibliotekę, aby analizować XML w strukturach danych Ruby. Aby pobrać lub zainstalować XmlSimple, odwiedź stronę http://xml-simple.rubyforge.org/

Gdy na komputerze uruchomi się kopia Ruby, możesz użyć pakietu Net:HTTP do wysyłania podstawowych żądań do usług danych Google. Fragment kodu poniżej pokazuje, jak dokonać niezbędnych importów z interaktywnej powłoki Ruby. Aby to zrobić, wymagamy pakietu „net/http”, analizujemy adres URL najpopularniejszego kanału wideo w YouTube, a potem wykonujemy żądanie HTTP GET.

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>

To żądanie powinno przywrócić odpowiedni fragment kodu XML do wiersza poleceń. Zwróć uwagę, że wszystkie elementy znajdują się w elemencie <feed> i są nazywane elementami <entry>. Nie musimy jeszcze martwić się o formatowanie XML. Chcę natomiast wyjaśnić, jak wykonać podstawowe żądanie do interfejsu Google Data API za pomocą protokołu HTTP. W związku z tym zmienimy interfejs API i skoncentrujemy się na arkuszach kalkulacyjnych, ponieważ informacje, które możemy wysyłać i pobierać, są bardziej przystępne dla użytkowników.

Uwierzytelnianie | Korzystanie z interfejsu API Arkuszy Google

Zaczniemy od pobrania pliku danych elementów. Tym razem chcemy skorzystać z własnych arkuszy kalkulacyjnych. Aby to zrobić, musimy najpierw uwierzytelnić się za pomocą usługi kont Google.

Jak być może pamiętasz z dokumentacji dotyczącej uwierzytelniania GData, istnieją dwa sposoby uwierzytelniania w usługach Google. AuthSub jest przeznaczony do aplikacji internetowych i w skrócie obejmuje proces wymiany tokenów. Prawdziwą zaletą protokołu AuthSub jest to, że nie musi ona przechowywać danych logowania użytkownika. Nazwa ClientLogin dotyczy aplikacji „zainstalowanych”. Podczas procesu ClientLogin nazwa użytkownika i hasło są przesyłane do usług Google przez https wraz z ciągiem znaków określającym usługę, której chcesz użyć. Usługa Google Arkuszes API jest określana przez ciąg znaków wise.

Wróćmy do naszej interaktywnej powłoki, aby uwierzytelnić się w Google. Pamiętaj, że do przesyłania żądań uwierzytelniania i danych logowania używamy https:

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. Po uwierzytelnieniu spróbujmy pobrać własne arkusze za pomocą

http://spreadsheets.google.com/feeds/spreadsheets/private/full

Ponieważ jest to uwierzytelniona prośba, przekazujemy też nasze nagłówki. W związku z tym, że będziemy wysyłać kilka żądań różnych kanałów, dobrym pomysłem może być użycie prostej funkcji o nazwie get_feed.

# 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> ...

Ponownie widzimy dużo kodu XML, który został zorientowany powyżej, ponieważ nie trzeba się martwić o jego odszyfrowywanie z poziomu wiersza poleceń. Aby zwiększyć wygodę użytkowników, przeanalizujmy strukturę danych za pomocą XmlSimple:

# 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 ]

Uzyskiwanie arkuszy

Tak jak widać powyżej, mój plik danych zawiera 6 arkuszy kalkulacyjnych. Aby ten artykuł był krótki, przycięliśmy pozostałą część kodu XML (i większość innych informacji o produkcie). Aby dowiedzieć się więcej, musisz wykonać jeszcze kilka czynności:

Uzyskiwanie klucza arkusza kalkulacyjnego
Aby pobrać plik arkusza, użyj klucza arkusza kalkulacyjnego
Uzyskaj identyfikator arkusza, którego chcesz użyć
Aby uzyskać dostęp do faktycznych treści arkusza, poproś o dostęp do komórek (feedFeed) lub listy (FeedFeed)

Może się to wydawać bardzo pracochłonne, ale pokażę Ci, że wszystko jest łatwe, jeśli napiszesz kilka prostych metod. Komórki kanałów i listy kanału są 2 różnymi reprezentacjami rzeczywistej zawartości komórek w arkuszu. Element listFeed reprezentuje cały wiersz informacji. Jest on zalecany w przypadku POSTowania nowych danych. Komórka kanały przedstawia poszczególne komórki i jest używana do aktualizowania pojedynczych komórek lub wsadowych aktualizacji wielu pojedynczych komórek (oba przy użyciu PUT). Więcej informacji znajdziesz w dokumentacji interfejsu API arkuszy kalkulacyjnych Google.

Najpierw musimy wyodrębnić klucz arkusza (wyróżniony w danych wyjściowych powyżej) w celu uzyskania pliku arkusza:

# 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 ]

Jak widzimy, możemy teraz znaleźć linki (highlighted above) umożliwiające dostęp do listFeed i FeedFeed. Zanim przejdziemy do zapoznania się z listą plików danych, krótko wyjaśnimy, jakie dane znajdują się obecnie w naszym przykładowym arkuszu kalkulacyjnym. Dzięki temu dowiesz się, czego szukamy:

Nasz arkusz kalkulacyjny jest bardzo prosty i wygląda tak:

language,	witryna
JAVA	http://java.com
php	http://php.net

A te dane są widoczne w pliku danych z listy:

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 ]

Jak widać, element listFeed zwraca zawartość arkusza przez utworzenie wpisu dla każdego wiersza. Zakładamy, że pierwszy wiersz arkusza kalkulacyjnego zawiera nagłówki komórek, a następnie dynamicznie generuje nagłówki XML na podstawie danych z tego wiersza. Więcej informacji na ten temat znajdziesz w rzeczywistym pliku XML:

<?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>

Oto krótkie porównanie:

# 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 ]

Widać tutaj 6 wpisów, po jednym dla każdej komórki. Pozostałe dane wyjściowe zostały usunięte poza wartością komórki A1, która zawiera słowo „language”. Zwróć też uwagę na link edytuj widoczny powyżej. Ten link zawiera ciąg znaków wersji (8srvbs). Ciąg wersji jest istotny przy aktualizacji danych komórek, ponieważ robimy to na końcu tego artykułu. Dzięki temu aktualizacje nie zostaną zastąpione. Za każdym razem, gdy przesyłasz żądanie PUT do zaktualizowania danych komórek, musisz uwzględnić w żądaniu najnowszą wersję tej komórki. Po każdej aktualizacji będzie zwracany nowy ciąg wersji.

Publikowanie treści w pliku danych list

Aby przesłać treść, potrzebujemy linku POST do listy. Ten link zostanie zwrócony po wysłaniu prośby o plik danych z listą. Będzie on zawierać adres URL http://schemas.google.com/g/2005#post jako wartość atrybutu rel. Musisz przeanalizować ten element linku i wyodrębnić jego atrybut href. Najpierw utworzymy małą metodę, która ułatwi publikowanie:

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>

Stan 201 oznacza, że Twój post został zrealizowany.

Aktualizowanie treści za pomocą komórek

Z dokumentacji wynika, że plik danych komórek preferuje żądania PUT w przypadku istniejących treści. Ale skoro informacje, które pobieraliśmy z komórek powyżej, to dane tylko już w rzeczywistym arkuszu kalkulacyjnym, jak możemy dodać nowe informacje? Musisz tylko wysłać żądanie dla każdej pustej komórki, do której chcesz wpisać dane. Fragment kodu poniżej pokazuje, jak pobrać pustą komórkę R5C1 (wiersz 5, kolumna 1), w której chcesz wstawić informacje o języku programowania w języku Python.

Pierwotna zmienna cellfeed_uri zawierała tylko identyfikator URI samego pliku danych. Teraz chcemy dołączyć komórkę, którą zamierzamy edytować, i uzyskać ciąg znaków tej wersji, aby wprowadzić zmiany:

# 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>"

Jak widzisz powyżej w kodzie kodu, ciąg znaków wersji to 47pc. Być może trzeba będzie przewinąć do prawej strony. Aby ułatwić zrozumienie, utwórz metodę pozwalającą uzyskać wersję, która jest dowolną wersją danej komórki:

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

Możemy wcisnąć metodę pozwalającą wykonać żądanie PUT, ale być może lepiej, jeśli pozwoli nam przeprowadzić całą aktualizację zbiorczą. Funkcja będzie pobierać tablicę zawierającą następujące zmienne:

:batch_id – unikalny identyfikator każdego żądania zbiorczego.
:cell_id – identyfikator komórki do zaktualizowania w formacie R#C#, gdzie komórka A1 będzie reprezentowana jako R1C1.
:data – dane, które chcemy wstawić.

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 ]

Jak widać, otrzymaliśmy żądanie zbiorcze, ponieważ otrzymaliśmy kod odpowiedzi 200 OK. Analizując kod XML odpowiedzi, możemy stwierdzić, że dla każdej wartości :batch_id ustawionej w tablicy response_data jest zwracana osobna wiadomość. Więcej informacji o przetwarzaniu wsadowym znajdziesz w dokumentacji Przetwarzanie zbiorcze w GData.

Podsumowanie

Jak widać, można bez trudu użyć interaktywnej powłoki Ruby, aby wypróbować interfejsy API danych Google. mieliśmy dostęp do naszych arkuszy kalkulacyjnych i arkuszy zarówno za pomocą listFeed, jak i FeedFeed. Wprowadziliśmy też nowe dane za pomocą żądania POST, a następnie napisaliśmy metody aktualizacji zbiorczej, obejmujące tylko około 120 wierszy kodu. Od tej chwili łączenie kilku prostych metod w klasę i tworzenie struktury do wielokrotnego użytku nie powinno być zbyt trudne.

Jeśli masz pytania dotyczące korzystania z tych narzędzi w ulubionym interfejsie API danych Google, skontaktuj się z nami, korzystając z grup dyskusyjnych.

Plik zajęć z przykładami kodu opisanymi powyżej znajdziesz na stronie http://code.google.com/p/google-data-samples-ruby.

Porozmawiaj o tym artykule.