Google Data API Tips

Updating a Google Site Listpage/Listitem

2010-03-15T14:55:00.000-07:00

Here is a quick and dirty (by fully functional) sample of updating a listpage/listitem in Google Sites using the Data API.

#!/usr/bin/python

import getpass
import gdata.sites.client
import gdata.sites.data

USER = 'test@example.com'
SITE = 'YOUR_SITE_NAME'
DOMAIN = 'YOUR_DOMAIN'  # or 'site' if you're not using a Google Apps domain.

# Setup our client.
client = gdata.sites.client.SitesClient(source='google-SitesListeItemUpdateTest', site=SITE, domain=DOMAIN)
client.ClientLogin(USER, getpass.getpass(), client.source)
client.ssl = True
client.http_client.debug = False

# Only fetch listpages.
feed = client.GetContentFeed(uri=client.MakeContentFeedUri() + '?kind=listpage')

# Work with first listpage we found.
lp = feed.GetListPages()[0]

print 'Listpage columns:'
for col in lp.data.column:
  print 'index: %s, name: %s' % (col.index, col.name)

# Query the listpage's listems and work with first row found.
li = client.GetContentFeed(uri=lp.feed_link.href).entry[0]

print 'Row contents:'
for field in li.field:
  print 'index: %s, name: %s, value: %s' % (field.index, field.name, field.text)

# Update the first fields/column's value.
li.field[0].text = 'Someone else'
entry = client.Update(li)

# Update the listpage's column heading.
#lp.data.column[0].name = 'New Heading'
#entry2 = client.Update(lp)

Download your DocList arbitrary file uploads in .NET

2010-01-13T13:18:00.000-08:00

The .NET client's Download() method currently handles exporting documents, presentations, and spreadsheets. However, it cannot download PDFs or arbitrary file types. Those types cannot be exported to different formats. Instead, you need to override the Download() method in docsrequest.cs to hit the content src link:

public Stream Download(Document document) {
  string queryUri = "";
  Service s = this.Service;

  string downloadUrl = document.DocumentEntry.Content.Src.ToString();
  Uri target = new Uri(downloadUrl);

  return s.Query(target);
}

Making a Calendar public via the ACL feed

2009-12-30T12:09:00.000-08:00

Google Calendar allows individual calendars to be marked as public, meaning that they can be accessed either via the Calendar UI, embeded calendars, or the Calendar Data API without requiring a password.

Normally, this option is enabled from within the Calendar UI. However, it can be enabled using the Calendar Data API as well. To do so, you'd send the following HTTP request:

POST /calendar/feeds/default/acl/full
Host: www.google.com

In this case, this will make the default calendar as public. If you want to make a secondary calendar public, replace default in the request's location with the desired calendar ID.

Update a document's content in .NET

2009-08-24T18:55:00.000-07:00


class Demo {
  private DocumentsService service = null;

  public Demo() {
    service = new DocumentsService("google-DocUpdateTip-v1");
    service.setUserCredentials("username@gmail.com", "pa$$word");
    GDataGAuthRequestFactory reqFactory = (GDataGAuthRequestFactory)service.RequestFactory;
    reqFactory.ProtocolMajor = 3;
  }

  static void Main(string[] args) {
    Demo demo = new Demo();

    // Fetch only documents
    DocumentsListQuery query = new DocumentsListQuery("http://docs.google.com/feeds/default/private/full/-/document");
    DocumentsFeed doclistFeed = demo.service.Query(query);

    // Update first document found
    DocumentEntry entry = (DocumentEntry)doclistFeed.Entries[0];
    Console.WriteLine("Updating " + entry.Title.Text + "...");

    DocumentEntry updatedEntry = demo.UpdateDocContents(entry, "C:/Documents and Settings/replacement.doc");
    Console.WriteLine(entry.Title.Text + " Updated!, view at " + entry.AlternateUri.ToString());
  }

  public DocumentEntry UpdateDocContents(DocumentEntry entryToUpdate, String replacementFileName) {
    FileInfo fileInfo = new FileInfo(replacementFileName);
    FileStream stream = fileInfo.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

    DocumentEntry entry = null;

    try {
      // Convert the extension to caps and strip the "." off the front
      String ext = fileInfo.Extension.ToUpper().Substring(1);

      String contentType = (String)DocumentsService.GDocumentsAllowedTypes[ext];
      if (contentType == null) {
        throw new ArgumentException("File extension '" + ext + "' is not recognized as valid.");
      }
      
      // Set ETag because we're making an update
      GDataRequestFactory factory = (GDataRequestFactory)service.RequestFactory;
      factory.CustomHeaders.Add("If-Match: " + entryToUpdate.Etag);

      Uri mediaUri = new Uri(entryToUpdate.MediaUri.ToString());
      entry = service.Update(mediaUri, stream, contentType, entryToUpdate.Title.Text) as DocumentEntry;
    } finally {
      stream.Close();
    }

    return entry;
  }
}

Create a new Google Docs Spreadsheet from content using AJAX

2009-07-27T15:01:00.000-07:00

This example shows how one could use jQuery to make an AJAX request that creates new Google Docs Spreadsheet from existing text/csv content. This particular examples uses ClientLogin

<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.1/jquery.min.js"
        type="text/javascript"></script>

<script type="text/javascript">
var token = 'YOUR_CLIENTLOGIN_AUTH_TOKEN';

function constructContentBody(docTitle, docType, contentBody, contentType) {
  var atom = ["<?xml version='1.0' encoding='UTF-8'?>",
              '<entry xmlns="http://www.w3.org/2005/Atom">',
              '<category scheme="http://schemas.google.com/g/2005#kind"',
              ' term="http://schemas.google.com/docs/2007#', docType, '"/>',
              '<title>', docTitle, '</title>',
              '</entry>'].join('');
             
  var body = ['--END_OF_PART\r\n',
              'Content-Type: application/atom+xml;\r\n\r\n',
              atom, '\r\n',
              '--END_OF_PART\r\n',
              'Content-Type: ', contentType, '\r\n\r\n',
              contentBody, '\r\n',
              '--END_OF_PART--\r\n'].join('');
  return body;
}

function createSpreadsheetFromContent(title, content, contentType) {
  netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");

  $.ajax({
    type: 'POST',
    url: 'http://docs.google.com/feeds/documents/private/full',
    contentType: 'multipart/related; boundary=END_OF_PART',
    data: constructContentBody(title, 'spreadsheet', content, contentType),
    dataType: 'xml',
    beforeSend: function(xhr) {
      $('#data').html('uploading...');
      xhr.setRequestHeader('Authorization', 'GoogleLogin auth=' + token);
    },
    success: function(resp) {
      $('#data').html('Spreadsheet created!');
    }
  });
}
</script>
</head>
<body>

<div id="data"></div>

<button onclick="createSpreadsheetFromContent('ANewTitle', '1,2,3,4', 'text/csv')">Create spreadsheet w/ content</button>
</body>
</html>

Download a Google Doc using the PHP library

2009-07-15T13:15:00.000-07:00

At the time of writing this tip, the Zend_Gdata_Docs component of the PHP library does not contain the export/download functionality of the DocList API. Here is an example of using AuthSub and file_get_contents() to download a document as a .txt file:

function download($client, $url, $format=null) {
  $sessionToken = $client->getHttpClient()->getAuthSubToken();
  $opts = array(
    'http' => array(
      'method' => 'GET',
      'header' => "GData-Version: 3.0\r\n".
                  "Authorization: AuthSub token=\"$sessionToken\"\r\n"
    )
  );
  if ($url != null) {
    $url =  $url . "&exportFormat=$format";
  }
  return file_get_contents($url, false, stream_context_create($opts));
}

// TODO 1: setup a Zend_Gdata_Docs client in $docs_client
// TODO 2: fetch a $feed or $entry
$contentLink = $feed->entries[0]->content->getSrc();
$fileContents = download($docs_client, $contentLink, 'txt');
echo 'Contents of document "' . $feed->entries[0]->title . '":<hr>';
echo "<pre>$fileContents</pre>";

OAuth in Google App Engine

2009-04-06T16:46:00.000-07:00

This sample demonstrates a basic structure that you can use to perform 3-legged OAuth using the Google Data Python client library in Google App Engine. This particular example talks to the Documents List Data API.

App Engine (Python) + OAuth sample

Note: The sample is available in two versions, one that signs requests with RSA-SHA1 and another that signs with HMAC-SHA1.

Retrieving a document's content URL in Java

2009-01-05T22:00:00.000-08:00

If you have a published document, its contents can be viewed by fetching the DocumentListEntry object's <content> src URL:

List<DocumentListEntry> entries = resultFeed.getEntries();
for (DocumentListEntry entry : entries) {
  MediaContent content = (MediaContent)entry.getContent();
  System.out.println("View '" + entry.getTitle().getPlainText() + "' at " + content.getUri());        
}

Geo-Tagging a Picasa Photo in PHP

2008-12-09T12:46:00.000-08:00

Assuming that $gp is a Zend_Gdata_Photos object, this will tag the $photoEntry with the specified latitude and longitude. (Note you still have to insert or update the $photoEntry.)

$gp->registerPackage('Zend_Gdata_Geo');
$gp->registerPackage('Zend_Gdata_Geo_Extension');
$where = $gp->newGeoRssWhere();
$position = $gp->newGmlPos('37.0 -122.0');
$where->point = $gp->newGmlPoint($position);
$photoEntry->setGeoRssWhere($where);

Constructing unsupported XML elements using the PHP client library

2008-12-05T16:13:00.000-08:00

When a new XML element is introduced, client library support needs to be added. At times, the services move a bit faster than the client libraries. This means that (as per the AtomPub spec) clients must store all unknown elements returned from the server. Clients may also wish to be able to use new functionality which isn't explicitly supported yet in the libraries, so clients can allow you to create arbitrary XML elements and attach them to entries.

The PHP client library accomplishes this using extension elements, represented as instances of Zend_Gdata_App_Extension_Element. Each time the server returns an element that is unknown to the client library, the client creates an instance of that class and stores it in the extensionElements array of the class representing the parent element. In order to send arbitrary XML, you can also construct a new Zend_Gdata_App_Extension_Element and place it in the extensionElements array.

As an example, Google Base added a publishing priority option, specified by adding a <gm:publishing_priority> element. At the time of this post, the element isn't supported by a class in the PHP client library, so here's how you can add it.

<?php
require_once 'Zend/Gdata/Gbase.php';
require_once 'Zend/Gdata/App/Extension/Element.php';

$base = new Zend_Gdata_Gbase();
$entry = $base->newItemEntry();

// Constructing a Zend_Gdata_App_Extension_Control
$control = $base->newControl(); 

// Constructing the extension element, and placing it into the array
// of extension owned by the class representing the parent app:control element.
// Arguments: 
//   element name (including prefix)
//   namespace prefix
//   namespace URI
//   text node of the new element
$control->extensionElements = array(
  new Zend_Gdata_App_Extension_Element('gm:publishing_priority', 'gm', 'http://base.google.com/ns-metadata/1.0', 'high')
);
$entry->control = $control;

Of course, if you discover missing elements, please feel free to file an issue in the Zend Framework issue tracker and, since it's open source, you can also contribute a fix back to the project. More information on contributing can be found on the Zend Framework wiki.

Using the JavaScript Client Library w/ non-supported Services

2008-12-03T21:34:00.000-08:00

The JavaScript client library has helper methods for Calendar, Contacts, Blogger, and Google Finance. However, you can use it with just about any Google Data API to access authenticated/private feeds. This example uses the DocList API.

<script src="http://www.google.com/jsapi" type="text/javascript"></script>
<script type="text/javascript">
google.load('gdata', '1.x');
google.setOnLoadCallback(initialize);

function initialize() {
  var scope = 'http://docs.google.com/feeds/';
  if (google.accounts.user.checkLogin(scope)) {   
    var service = new google.gdata.client.GoogleService('writely', 'DocList-App-v1.0'); 
    service.getFeed(scope + 'documents/private/full/', handleFeed, handleError);
  } else {
    var token = google.accounts.user.login(scope); // can ignore returned token
  }
};

var handleFeed = function(response) {
  var entries = response.feed.entry;
  if (!entries.length) {
    alert('You have no entries!');
    return;
  }
  var html = [];
  for (var i = 0, entry; entry = entries[i]; i++) {
    var title = entry.title.$t;
    html.push('<li>' + title + '</li>');
  }
  document.getElementById('data').innerHTML = html.join('');
};

var handleError = function(e) {
  alert('Error: ' + e.cause ? e.cause.statusText : e.message);
};
</script>

<div id="data"><!-- dynamically filled --></div>

2 Legged OAuth in Python

2008-11-23T10:05:00.000-08:00

Google Apps Premier/Education administrators can take advantage of 2 legged OAuth to communicate with the Google Data APIs. If you're using the Google Data Python client library 1.2.3+: An updated sample is here available here. Otherwise, if you're stuck with an older version of the library (< 1.2.3), you can use the Python OAuth library from oauth.net.

import urllib
import oauth
import gdata.contacts
import gdata.contacts.service

CONSUMER_KEY = 'yourdomain.com'
CONSUMER_SECRET = 'YOUR_CONSUMER_SECRET'
CONTACTS_URL = 'http://www.google.com/m8/feeds/contacts/default/full'

# Setup 2 legged OAuth consumer based on our admin "credentials"
consumer = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET)

user = 'any.user@yourdomain.com'
params = {'max-results': 50, 'xoauth_requestor_id': user}

# Construct the request manually and sign it using HMAC-SHA1
# Note: The params dictionary needs to be passed in separately from the base URL
request = oauth.OAuthRequest.from_consumer_and_token(
   consumer, http_method='GET', http_url=CONTACTS_URL, parameters=params)
request.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), consumer, None)

# See patch @ http://code.google.com/p/oauth/issues/detail?id=31
headers = request.to_header()

client = gdata.contacts.service.ContactsService()

# Query the user's contacts and print their name & email
uri = '%s?%s' % (request.http_url, urllib.urlencode(params))
feed = client.GetFeed(uri, extra_headers=headers, converter=gdata.contacts.ContactsFeedFromString)
for entry in feed.entry:
 print '%s, %s' % (entry.title.text, entry.email[0].address)

Paging Through Feeds in Python

2008-11-21T11:17:00.000-08:00

If you have a feed object you use

feed.GetNextLink().href

to find the URL of the next page of results. Then you can use that to query for more like so:

nextPageFeed = service.Query(feed.GetNextLink().href)

Dealing with YouTube videos that you can't embed

2008-11-20T13:32:00.000-08:00

If you are using the YouTube Player APIs you will notice that some videos will refuse to load on your site. This is because the owner of that video has requested that embedding be disabled. You can tell on the video watch page because it will say "Embedding disabled by request" in place of the standard embed code:

http://www.youtube.com/watch?v=juPxfHO50oo

If you are retrieving videos to display using the Data API you should use the format parameter set to 5 in order to filter out non-embeddable videos:

http://gdata.youtube.com/feeds/api/videos?v=2&format=5

The Data API also has the <yt:noembed> tag included in the video entry when the video cannot be embedded. A video entry can be retrieved using:

http://gdata.youtube.com/feeds/api/videos/VIDEO_ID

If you are using the Player JavaScript or AS2 API you should also handle the onError event.

2 Legged OAuth in PHP

2008-11-20T09:33:00.000-08:00

Google Apps Premier/Education administrators can take advantage of 2 legged OAuth to communicate with the Google Data APIs. This sample makes use of the PHP OAuth library from oauth.net.

<?php
require_once('OAuth.php');

// Establish an OAuth consumer based on our admin 'credentials'
$CONSUMER_KEY = 'yourdomain.com'; 
$CONSUMER_SECRET = 'YOUR_CONSUMER_SECRET'; 
$consumer = new OAuthConsumer($CONSUMER_KEY, $CONSUMER_SECRET, NULL);

// Setup OAuth request based our previous credentials and query
$user= 'any.user@yourdomain.com';
$base_feed = 'http://www.google.com/m8/feeds/contacts/default/full/';
$params = array('max-results' => 10, 'xoauth_requestor_id' => $user);
$request = OAuthRequest::from_consumer_and_token($consumer, NULL, 'GET', $base_feed, $params);

// Sign the constructed OAuth request using HMAC-SHA1
$request->sign_request(new OAuthSignatureMethod_HMAC_SHA1(), $consumer, NULL);

// Make signed OAuth request to the Contacts API server
$url = $base_feed . '?' . implode_assoc('=', '&', $params);
echo send_request($request->get_normalized_http_method(), $url, $request->to_header());
 
/**
 * Makes an HTTP request to the specified URL
 * @param string $http_method The HTTP method (GET, POST, PUT, DELETE)
 * @param string $url Full URL of the resource to access
 * @param string $auth_header (optional) Authorization header
 * @param string $postData (optional) POST/PUT request body
 * @return string Response body from the server
 */
function send_request($http_method, $url, $auth_header=null, $postData=null) {
  $curl = curl_init($url);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_FAILONERROR, false);
  curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);

  switch($http_method) {
    case 'GET':
      if ($auth_header) {
        curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header)); 
      }
      break;
    case 'POST':
      curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/atom+xml', 
                                                   $auth_header)); 
      curl_setopt($curl, CURLOPT_POST, 1);                                       
      curl_setopt($curl, CURLOPT_POSTFIELDS, $postData);
      break;
    case 'PUT':
      curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/atom+xml', 
                                                   $auth_header)); 
      curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $http_method);
      curl_setopt($curl, CURLOPT_POSTFIELDS, $postData);
      break;
    case 'DELETE':
      curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header)); 
      curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $http_method); 
      break;
  }
  $response = curl_exec($curl);
  if (!$response) {
    $response = curl_error($curl);
  }
  curl_close($curl);
  return $response;
}

/**
 * Joins key:value pairs by inner_glue and each pair together by outer_glue
 * @param string $inner_glue The HTTP method (GET, POST, PUT, DELETE)
 * @param string $outer_glue Full URL of the resource to access
 * @param array $array Associative array of query parameters
 * @return string Urlencoded string of query parameters
 */
function implode_assoc($inner_glue, $outer_glue, $array) {
  $output = array();
  foreach($array as $key => $item) {
    $output[] = $key . $inner_glue . urlencode($item);
  }
  return implode($outer_glue, $output);
}
?>

XML PHP Pretty Printer

2008-11-20T07:45:00.000-08:00

<?
/** Prettifies an XML string into a human-readable and indented work of art
 *  @param string $xml The XML as a string
 *  @param boolean $html_output True if the output should be escaped (for use in HTML)
 */
function xmlpp($xml, $html_output=false) {
    $xml_obj = new SimpleXMLElement($xml);
    $level = 4;
    $indent = 0; // current indentation level
    $pretty = array();
    
    // get an array containing each XML element
    $xml = explode("\n", preg_replace('/>\s*</', ">\n<", $xml_obj->asXML()));

    // shift off opening XML tag if present
    if (count($xml) && preg_match('/^<\?\s*xml/', $xml[0])) {
      $pretty[] = array_shift($xml);
    }

    foreach ($xml as $el) {
      if (preg_match('/^<([\w])+[^>\/]*>$/U', $el)) {
          // opening tag, increase indent
          $pretty[] = str_repeat(' ', $indent) . $el;
          $indent += $level;
      } else {
        if (preg_match('/^<\/.+>$/', $el)) {            
          $indent -= $level;  // closing tag, decrease indent
        }
        if ($indent < 0) {
          $indent += $level;
        }
        $pretty[] = str_repeat(' ', $indent) . $el;
      }
    }   
    $xml = implode("\n", $pretty);   
    return ($html_output) ? htmlentities($xml) : $xml;
}

echo '<pre>' . xmlpp($xml, true) . '</pre>';
?>

Accessing a feed using ClientLogin & Ruby

2008-11-14T15:20:00.000-08:00

Example of accessing the DocList API using ClientLogin in Ruby:

require 'net/http'
require 'net/https'
require 'cgi'
require 'rubygems'
require 'xmlsimple'
require 'pp'

def get_feed(uri, headers=nil)
  uri = URI.parse(uri)
  Net::HTTP.start(uri.host, uri.port) do |http|
    return http.get(uri.path, headers)
  end
end

email = 'user@gmail.com'
password = CGI::escape('pa$$word')
service = 'writely'
source = 'MyCompany-MyApp-0.1'
path = '/accounts/ClientLogin'

data = ["accountType=HOSTED_OR_GOOGLE", 
        "Email=#{email}",
        "Passwd=#{password}",
        "service=#{service}",
        "source=#{source}"].join('&')

http = Net::HTTP.new(host='www.google.com', port=443)
http.use_ssl = true
http.start

headers = {'Content-Type' => 'application/x-www-form-urlencoded'}
resp, data = http.post(path, data, headers)

token = data[/Auth=(.*)/, 1]  # parse out the Auth token

headers['Authorization'] = "GoogleLogin auth=#{token}"
resp = get_feed('http://docs.google.com/feeds/documents/private/full', headers)

doc = XmlSimple.xml_in(resp.body, 'KeyAttr' => 'name')
pp doc

Force PHP to use a Google Account in ClientLogin

2008-10-31T11:00:00.000-07:00

Sometimes you have a Google Apps account that is also registered as a Google Account and you want to make sure you are logging in as the Google Account, especially when you want to use a service like Picasa Web Albums that does not have an Apps version. To do this using ClientLogin you need to do something like:

$serviceName = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
$username = "user@gmail.com";
$pass = "password";
$accountType = "GOOGLE";


$client = Zend_Gdata_ClientLogin::getHttpClient($username, $pass, $serviceName, null, Zend_Gdata_ClientLogin::DEFAULT_SOURCE, null, null, Zend_Gdata_ClientLogin::CLIENTLOGIN_URI, $accountType);

Using AuthSub on App Engine

2008-10-23T11:24:00.000-07:00

For a full explanation, see this article: Retrieving Authenticated Google Data Feeds with Google App Engine

    # Initialize a client to talk to Google Data API services.
    client = gdata.service.GDataService()
    gdata.alt.appengine.run_on_appengine(client)

    session_token = None
    # Find the AuthSub token and upgrade it to a session token.
    auth_token = gdata.auth.extract_auth_sub_token_from_url(self.request.uri)
    if auth_token:
      # Upgrade the single-use AuthSub token to a multi-use session token.
      session_token = client.upgrade_to_session_token(auth_token)
    if session_token and users.get_current_user():
      # If there is a current user, store the token in the datastore and
      # associate it with the current user. Since we told the client to
      # run_on_appengine, the add_token call will automatically store the
      # session token if there is a current_user.
      client.token_store.add_token(session_token)
    elif session_token:
      # Since there is no current user, we will put the session token
      # in a property of the client. We will not store the token in the
      # datastore, since we wouldn't know which user it belongs to.
      # Since a new client object is created with each get call, we don't
      # need to worry about the anonymous token being used by other users.
      client.current_token = session_token

Uploading a private YouTube video in .NET

2008-10-10T11:50:00.000-07:00

newEntry.Media.ExtensionElements.Add(new Google.GData.YouTube.Private());

Changing the default timeout for HTTP requests in PHP

2008-10-09T14:23:00.000-07:00

If you are using the PHP client library to upload videos to YouTube, you may run into problems where your requests are timing out after ten seconds. The client library makes use of the Zend_Http_Client component to dispatch requests to the API server. By default the client object is initialized to time out any requests after 10 seconds. The snippet below shows how you may increase the timeout to 30 seconds:

// assuming your Zend_Http_Client already exists as $httpClient
// and that you want to change the timeout from the 10 second default to 30 seconds
$config = array('timeout' => 30);
$httpClient->setConfig($config);

Saving a Feed or Entry as XML with the .NET client library

2008-10-03T11:19:00.000-07:00

The SaveToXml() method takes either a Stream or a XmlWriter.

FileStream file = new FileStream("C:\\testxml.txt", FileMode.Create);
feed.SaveToXml(file);
file.Close();

Getting RTSP Streams From the YouTube API Without Redirects

2008-10-03T10:12:00.001-07:00

So if you want RTSP streams from the YouTube API you probably looked at our documentation for the format parameter and made a request like

http://gdata.youtube.com/feeds/api/videos?format=1

http://gdata.youtube.com/feeds/api/videos?format=6

or even

http://gdata.youtube.com/feeds/api/videos?format=1,6

But you may have noticed you get a lot of redirects, which may upset your RTSP player. What you should be doing is requesting the mobile projection. So your request should look like

http://gdata.youtube.com/feeds/mobile/videos?format=1

Retrieving a user profile image in YouTube using Python

2008-09-24T10:15:00.000-07:00

import gdata.youtube
import gdata.youtube.service

yt_service = gdata.youtube.service.YouTubeService()
user_entry = yt_service.GetYouTubeUserEntry(username='GoogleDevelopers')
print user_entry.thumbnail.url

Catching Exceptions from the Java Client Library

2008-09-21T20:11:00.000-07:00

Just like our other client libraries, if you're using the Java client library and encounter a server error, an exception will be generated. This will cause Java to stop in its tracks and print out the contents of the exception. While this is useful for debugging, in a production application you'll probably want your application to fail gracefully, perhaps displaying a nice error message to your users.

You can do this by wrapping your code in a try block and using an catch statement:

try {
  // Do something that accesses the network
} catch (IOError e) {
    // Insert custom error handling code here.
    System.out.println(e.toString());
} catch (ServiceException e) {
    // Insert custom error handling code here.
    System.out.println(e.toString());
}

Most errors will be instances of either IOError or ServiceException, depending on the cause.

Catching Exceptions from the Python Client Library

2008-09-21T18:17:00.000-07:00

If you're using the Python client library and encounter a server error, an exception will be generated, causing Python to stop in its tracks and print out the contents of the exception. While this is useful for debugging, in a production application you'll probably want your application to fail gracefully, perhaps displaying a nice error message to your users.

You can do this by wrapping your code in a try block and using an except statement:

try:
  # Do something that accesses the network
except gdata.service.RequestError, inst:
  response = inst[0]
  status = response['status']
  reason = response['reason']
  body = response['body']
  # Handle the error here

Other exceptions may be thrown depending on the situation. For more information, see the gdata.service documentation.

Adding Multiple Video Responses to a Video Entry

2008-09-19T10:39:00.000-07:00

Note that you need to use an authenticated YouTube client object (represented as $ytClient). You can only add responses that are your own videos and they may not show up immediately, depending on whether the owner of the video that you are responding to has enabled automatic acceptance of responses.

// Assuming we have just instantiated a working $httpClient object.
$ytClient = new Zend_Gdata_YouTube($httpClient, $applicationId, $clientId, $developerKey);

// The video ID that is to receive the responses.
$receiveResponses = 'ABC123';

// A few of your videos that you want to post as responses.
$videoResponses[] = 'defXYZ123';
$videoResponses[] = 'defXYZ124';
$videoResponses[] = 'defXYZ125';

function addVideoResponses($videoResponses, $receiveResponses) {
  global $ytClient;

  $receiveResponsesEntry = $yt->getVideoEntry($receiveResponses);

  foreach ($videoResponses as $videoResponse) {
    $videoResponseEntry = $yt->getVideoEntry($videoResponse);
    $responsesFeedUrl = $receiveResponsesEntry->getVideoResponsesLink()->getHref();

    try {
      $ytClient->insertEntry($videoResponseEntry, $responsesFeedUrl);
    } catch (Zend_Gdata_App_HttpException $httpException) {  
      echo 'ERROR: ' . $httpException->getRawResponseBody();
      
    }
  }
}

addVideoResponses($videoResponses, $receiveResponses);

Using the PHP Client Library through a Proxy connection

2008-09-17T11:31:00.000-07:00

To access a Google Data API through a proxy connection you will need to use the Zend_Http_Client_Adapter_Proxy proxy adapter. In the snippet below, we are going to access our private Google Documents feed from the DocumentsList API through a proxy connection:

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_App_HttpException');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Docs');

Zend_Loader::loadClass('Zend_Http_Client_Exception');
Zend_Loader::loadClass('Zend_Http_Client');
Zend_Loader::loadClass('Zend_Http_Client_Adapter_Proxy');


// Configure the proxy connection
$config = array(
    'adapter'    => 'Zend_Http_Client_Adapter_Proxy',
    'proxy_host' => 'your.proxy.server.net',
    'proxy_port' => 3128
);

// We are setting http://www.google.com:443 as the initial URL since we need to perform
// ClientLogin authentication first.
$proxiedHttpClient = new Zend_Http_Client('http://www.google.com:443', $config);

$username = 'foo@example.com';
$password = 'barbaz';
$service = Zend_Gdata_Docs::AUTH_SERVICE_NAME;

// Try to perform the ClientLogin authentication using our proxy client.
// If there is an error, we exit since it doesn't make sense to go on. You may want to 
// modify this according to the needs of your application.
try {
  $httpClient = Zend_Gdata_ClientLogin::getHttpClient($username, $password, $service,
    $proxiedHttpClient);
} catch (Zend_Gdata_App_HttpException $httpException) {
  exit("An error occurred trying to connect to the proxy server\n" .        
    $httpException->getMessage() . "\n");
}

// If that worked, proceed and retrieve the documents feed.
// Remember to set your application ID.
$docsClient = new Zend_Gdata_Docs($httpClient, $yourApplicationId);
$feed = $docsClient->getDocumentListFeed();

?>

Secure AuthSub using the Zend PHP library 1.6+

2008-09-15T15:43:00.000-07:00

After uploading a public certificate to https://www.google.com/accounts/ManageDomains, here's how to use the Zend PHP 1.6+ library to work with secure AuthSub. This example uses the Google Health Data API

<?
function setupClient($singleUseToken = null) { 
  $client = null;  

  // Fetch a new AuthSub token?
  if (!$singleUseToken) {
    $next = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
    $scope = 'https://www.google.com/health/feeds';
    $authSubHandler = 'https://www.google.com/health/authsub';    
    $secure = 1;
    $session = 1;
    $permission = 1;  // 1 - allows posting notices && allows reading profile data
    $authSubURL =  Zend_Gdata_AuthSub::getAuthSubTokenUri($next, $scope, $secure, $session, $authSubHandler);
    
    $authSubURL .= '&permission=' . $permission;
    
    echo '<a href="' . $authSubURL . '">Link your Google Health Account</a>';
  } else {
    $client = new Zend_Gdata_HttpClient();
    
    // This sets your private key to be used to sign subsequent requests
    $client->setAuthSubPrivateKeyFile('/path/to/myrsakey.pem', null, true);

    $sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken(trim($singleUseToken), $client);
    // Set the long-lived session token for subsequent requests
    $client->setAuthSubToken($sessionToken);
  }
  return $client;
}
?>

Use this function like this:

$client = setupClient(@$_GET['token']);
if ($client) {
  // Query a feed
} else {
  exit(); // Just display the AuthSub link
}

Update:Read the new documentation on using AuthSub for PHP as well as all the other client libraries.

Sending custom headers in the .NET client library

2008-09-15T07:25:00.001-07:00

Assume that "service" is an instance of an API-specific service object.

GDataRequestFactory requestFactory = (GDataRequestFactory) service.RequestFactory;
requestFactory.CustomHeaders.Add("X-MyHeader: HeaderValue");

Editing contact photos using curl

2008-09-09T18:18:00.000-07:00

You can use curl to modify Contacts API contact photos from the command line.

To start, you'll need to get the photo edit link from the contacts feed. This is expressed in the feed as the following XML element:

<link rel="http://schemas.google.com/contacts/2008/rel#photo-edit type="image/*" href="http://www.google.com/m8/feeds/photos/media/user/id/version" />

The photo edit link is contained inside the href attribute. For this example, it would be http://www.google.com/m8/feeds/photos/media/user/id/version.

Once you have this, you can add or update a photo by running:

curl -H "Authorization: GoogleLogin ..." \
-H "Content-Type: image/jpeg" \
-X PUT \
--binary-data "@/path/to/image.jpg" \
http://www.google.com/m8/feeds/photos/media/user/id/version

Be sure to replace the Content-Type and file path with appropriate values for your new photo.

To delete a photo, run:

curl -H "Authorization: GoogleLogin ..." \
-X DELETE \
http://www.google.com/m8/feeds/photos/media/user/id/version

You'll need to make sure that the Authorization header contains a valid ClientLogin token, as explained in the tip "Perform ClientLogin using curl.

Deleting contact photos using .NET

2008-09-09T18:12:00.001-07:00

If you want to delete a contact photo from the Contacts API using the .NET client library, you can just call ContactsService.Delete(photoURI), like so:

ContactsService service = new ContactsService("exampleCo-exampleApp-1");
service.setUserCredentials("user@example.com", "secretPassword");
ContactsQuery query = new ContactsQuery(ContactsQuery.CreateContactsUri("default"));

ContactsFeed feed = service.Query(query);
foreach (ContactEntry entry in feed.Entries)
{
  service.Delete(entry.PhotoEditUri);
}

Be careful, the above code will delete every contact photo in your contact list. Run this against a test account only.

Retrieving a single document entry using the Java client library

2008-09-03T13:08:00.001-07:00

The snippet below demonstrates how to retrieve a single DocumentListEntry using the Java client library:

import java.net.URL;

import com.google.gdata.client.docs.DocsService;
import com.google.gdata.data.docs.DocumentListEntry;

public class DocumentListGetEntry {

  public static void main(String[] args) {
    try {
      DocsService docsService = new DocsService("Document List Demo");
      docsService.setUserCredentials("foobar@example.com", "secret");
   
      URL documentURI = new URL("http://docs.google.com/feeds/documents/private/full/spreadsheet%3Apc6ppXdYxYkSSOvE8tCUELw");
      DocumentListEntry entry = docsService.getEntry(documentURI, DocumentListEntry.class);
   
      System.out.println(entry.getTitle().getPlainText());  
  
    } catch (Exception e) {
      System.err.println(e.toString());
    }
  }
}

Finding the previous and next links using SimpleXml

2008-08-25T15:54:00.000-07:00

If you find yourself in a situation where you need to page through a large feed of entries with SimpleXML, you can use the below snippet to retrieve the 'previous' and 'next' links:

// assuming you have read your XML string into the $sxml object
$links = $sxml->children('http://www.w3.org/2005/Atom'); 
foreach($links as $link) {
  foreach($link->attributes() as $key => $value) {
    if ($key == 'rel') {
      print "$key => $value\n";
    }
  }
}

Finding the total number of comments for a Video Entry with the Python Client Library

2008-08-25T11:54:00.001-07:00

The snippet below shows how to retrieve the total number of comments for a video entry by examining the comment feed object using the interactive shell:

>>> import gdata.youtube.service
>>> client = gdata.youtube.service.YouTubeService()
>>> feed = client.GetRecentlyFeaturedVideoFeed()
>>> # fetching the first entry from the recently featured video feed
>>> entry = feed.entry[0]
>>> entry.title.text
"Follow Obama's nomination week: youtube.com/2008conventions"
>>> # fetching the comment feed
>>> comments = client.GetYouTubeVideoCommentFeed(video_id='9N4GOpSt5OI')
>>> # printing the text contents of the total_results element
>>> # note that this element is part of every feed
>>> comments.total_results.text
'578'

Alternatively, if you want to eliminate the actual request to catch the comment feed itself, you can parse out the number of comments by examining the 'countHint' attribute of the comment feedLink:

>>> entry.comments.feed_link[0].count_hint
'50'

Uploading a video to YouTube using an older version of the Zend Framework, prior to 1.5.3

2008-08-19T13:41:00.000-07:00

We have recently added convenience methods that make uploading video entries to the YouTube API much easier than before. For those that are still using older versions of the PHP Client Library, prior to 1.5.3 of the Zend Framework, the snippet below explains how to upload a video entry. Note that this still works in version 1.5.3 and will continue to work in future revisions:

// assuming that $yt is a fully authenticated YouTube service object

// create a new Zend_Gdata_YouTube_VideoEntry object
$myVideoEntry = new Zend_Gdata_YouTube_VideoEntry();

// create a new Zend_Gdata_App_MediaFileSource object for your video file (if using direct upload)
$filesource = $yt->newMediaFileSource('/path/to/mytestmovie.mov');
$filesource->setContentType('video/quicktime');

// set slug header
$filesource->setSlug('mytestmovie.mov');

// add the filesource to the video entry
$myVideoEntry->setMediaSource($filesource);

// create a new Zend_Gdata_YouTube_Extension_MediaGroup object
$mediaGroup = $yt->newMediaGroup();
$mediaGroup->title = $yt->newMediaTitle()->setText('My Test Movie');
$mediaGroup->description = $yt->newMediaDescription()->setText('My description');

// the category must be a valid YouTube category
// optionally set some developer tags*
$mediaGroup->category = array(
$yt->newMediaCategory()->setText('Autos')->setScheme('http://gdata.youtube.com/schemas/2007/categories.cat'),
$yt->newMediaCategory()->setText('mydevelopertag')->setScheme('http://gdata.youtube.com/schemas/2007/developertags.cat'),
$yt->newMediaCategory()->setText('anotherdevelopertag')->setScheme('http://gdata.youtube.com/schemas/2007/developertags.cat')
);

// set keywords, please note that they cannot contain white-space
$mediaGroup->keywords = $yt->newMediaKeywords()->setText('cars, funny');
$myVideoEntry->mediaGroup = $mediaGroup;

// optionally set video location
$yt->registerPackage('Zend_Gdata_Geo');
$yt->registerPackage('Zend_Gdata_Geo_Extension');
$where = $yt->newGeoRssWhere();
$position = $yt->newGmlPos('37.0 -122.0');
$where->point = $yt->newGmlPoint($position);
$myVideoEntry->setWhere($where);


// upload URL for the currently authenticated user
$uploadUrl = 'http://uploads.gdata.youtube.com/feeds/users/default/uploads';

try {
$newEntry = $yt->insertEntry($myVideoEntry, $uploadUrl, 'Zend_Gdata_YouTube_VideoEntry');
} catch (Zend_Gdata_App_HttpException $httpException) {
echo $httpException->getRawResponseBody();
} catch (Zend_Gdata_App_Exception $e) {
echo $e->getMessage();
}

* Find out more about developer tags

Performing a GET with a POST using a Data API

2008-08-19T11:35:00.000-07:00

Sometimes you can only do a GET when you need to do a DELETE, since some systems don't support all of the HTTP verbs. Also since Flash doesn't let you set a custom Authorization header on a GET, sometimes you need to do a GET with a POST. How can you do this? With the X-HTTP-Method-Override header:

X-HTTP-Method-Override: GET

For example, say you want to perform a video search in YouTube using a POST request:

POST /feeds/api/videos HTTP/1.1
Host: gdata.youtube.com
X-HTTP-Method-Override: GET
Content-Length: 23
Content-Type: application/x-www-form-urlencoded

vq=kitten&max-results=1

This is the same as performing a GET on http://gdata.youtube.com/feeds/api/videos?vq=kitten&max-results=1 The POST body is used as the set of query parameters. You can also do this using the curl command:

curl -H "X-HTTP-Method-Override: GET" -X POST http://gdata.youtube.com/feeds/api/videos -d "vq=kitten&max-results=1"

Create a public album for Picasa Web Albums

2008-08-18T10:43:00.001-07:00

This is how to do it in .NET:

AlbumEntry newEntry = new AlbumEntry();
newEntry.Title.Text = "My New album";
newEntry.Summary.Text = "This is an album";
AlbumAccessor ac = new AlbumAccessor(newEntry);
ac.Access = "public";

This is how to do it in PHP:

$entry = new Zend_Gdata_Photos_AlbumEntry();
$entry->setTitle($gp->newTitle('title'));
$entry->setGphotoAccess($gp->newAccess("public"));
$createdEntry = $gp->insertAlbumEntry($entry);

Link a Google Base item to your website

2008-08-15T18:15:00.000-07:00

Here is how you can set the alternate link using the PHP client library. When someone clicks on your item in Google Base, he/she will be redirected to your site.

<?
$link = new Zend_Gdata_App_Extension_Link(); 
$link->setHref('http://www.example.com'); 
$link->setRel('alternate'); 
$link->setType('text/html');  
$linkArray[] = $link; 

$entry->setLink($linkArray); 
?>

Here is the underlying XML:

<link rel='alternate' type='text/html' href='http://www.example.com'/>

Setting publishing_priority attribute in .NET

2008-08-11T16:37:00.000-07:00

For items to be published immediately using the Google Base API, you must set the publishing_priority to 'high'. The default is 'low'.

If you're using 1.2.3+ of the .NET client:

GBaseEntry entry = new GBaseEntry();
entry.PublishingPriority = new PublishingPriority("high");
GBaseEntry myEntry = service.Insert(GBaseUriFactory.Default.ItemsFeedUri, entry);

Older versions:

GBaseEntry entry = new GBaseEntry();

XmlDocument xmlDocument = new XmlDocument();
XmlNode node = xmlDocument.CreateNode(XmlNodeType.Element, 
  "app", "control", "http://purl.org/atom/app#");
XmlNode pp = xmlDocument.CreateNode(XmlNodeType.Element, 
  "gm", "publishing_priority", "http://base.google.com/ns-metadata/1.0");

pp.InnerText = "high";
node.AppendChild(pp);

entry.ExtensionElements.Add(node);
GBaseEntry myEntry = service.Insert(GBaseUriFactory.Default.ItemsFeedUri, entry);

Getting the worksheet feed for a given spreadsheet

2008-08-07T08:59:00.000-07:00

This code snippet demonstrates how to obtain a feed of worksheet entries, given an authenticated gdata.spreadsheet.service.SpreadsheetsService() client object and a worksheet key. For the sake of the example, we are going to extract the worksheets feed for the first spreadsheet in our spreadsheets feed. The example uses the interactive Python interpreter. To obtain the worksheet feed for a private spreadsheet:

>>> import gdata
>>> import gdata.docs
>>> import gdata.spreadsheet
>>> import gdata.spreadsheet.service
>>> client = gdata.spreadsheet.service.SpreadsheetsService()
>>> client.email = 'me@gmail.com'
>>> client.password = 'mypassword'
>>> client.ProgrammaticLogin()
>>> spreadsheet_feed = client.GetFeed('http://spreadsheets.google.com/feeds/spreadsheets/private/full')
>>> first_entry = spreadsheet_feed.entry[0]
>>> key = first_entry.id.text.rsplit('/')[-1]
>>> worksheets_feed = client.GetWorksheetsFeed(key)
>>> for entry in worksheets_feed.entry:
...     print entry.title.text
...

To do the same without authentication for public spreadsheets: To obtain the worksheet feed for a private spreadsheet:

>>> import gdata.spreadsheet
>>> import gdata.spreadsheet.service
>>> client = gdata.spreadsheet.service.SpreadsheetsService()
>>> key = 'p123345abcDEF'
>>> worksheets_feed = client.GetWorksheetsFeed(key, visibility='public', projection='values')
>>> for entry in worksheets_feed.entry:
...     print entry.title.text
...

Catching Exceptions from the PHP Client Library

2008-08-05T10:19:00.001-07:00

If you are using the PHP client library and see an error like "Fatal error: Uncaught exception 'Zend_Gdata_App_HttpException' with message 'Expected response code 200, got 400' in ..." What you should really do is surround your code in a try block and use a catch statement like this:

catch(Zend_Gdata_App_HttpException $exception) {
    echo "Error: " . $exception->getResponse()->getRawBody();
}

Usually this will print a more informative message describing the reason for failure.

Getting Blogger Post URLs Using C#

2008-08-04T17:55:00.000-07:00

Want to look up the URL for a post retrieved using the Blogger API? If you're using the .NET client library, you can do it with one line of C# code:

string postUrl = entry.AlternateUri.Content;

Post on Blogger using curl

2008-08-04T15:16:00.000-07:00

This command line curl script reads an XML file containing the blog post's XML and uses curl to authenticate and post to Blogger. Here is the XML for an example post:

<entry xmlns="http://www.w3.org/2005/Atom">
  <title type="text">Knock knock</title>
  <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p>Who's there?</p>
      <p>Orange.</p>
      <p>Orange who?</p>
      <p>Orange you glad you know how to post using curl?!? (lol!)</p>
    </div>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="joke"/>
  <category scheme="http://www.blogger.com/atom/ns#" term="curl"/>
</entry>

With the above stored in blog_post.xml, we can now post it using the following shell script:

#!/bin/sh

# Authenticate
# Requires $GDATA_PASSWORD to be set as an environment variable.
G_AUTH_TOKEN=`curl 2>/dev/null https://www.google.com/accounts/ClientLogin \
    -d Email=YOUR_EMAIL_ADDRESS@example.com \
    -d Passwd=$GDATA_PASSWORD  \
    -d accountType=GOOGLE \
    -d source=curlExample \
    -d service=blogger \
  | grep '^Auth=' | cut -c 6-`

# Post on my blog.
curl -v --request POST -H "Content-Type: application/atom+xml" \
    -H "Authorization: GoogleLogin auth=$G_AUTH_TOKEN" \
    "http://www.blogger.com/feeds/YOUR_BLOGS_ID/posts/default" --data "@blog_post.xml"

Perform ClientLogin using curl

2008-08-04T15:07:00.000-07:00

Requests an authorization token for one of the Google Data API services and stores it in the shell environment variable GDATA_AUTH. This shell script takes three command line parameters, the email address for the desired account, password, and the service name of the service which the token will be used to access.

#!/bin/sh
export GDATA_AUTH=`curl 2>/dev/null https://www.google.com/accounts/ClientLogin \
  -d Email=$1 -d Passwd=$2 -d accountType=HOSTED_OR_GOOGLE -d source=curlExample \
  -d service=$3 | grep '^Auth=' | cut -c 6-`
echo $GDATA_AUTH

Create Calendar Gadget using the Google Data Java client library.

2008-08-04T15:03:00.000-07:00

Create Calendar Gadget (WebContent event) using the Google Data Java client library.

  public DateTime getToday() {

  Date today = new Date();

  DateTime datetime = new DateTime(today);

  datetime.setDateOnly(true);

  return datetime;  
}

public DateTime getTomorrow() {

  long oneDay = 24 * 60 * 60 * 1000;

  Date today = new Date();

  DateTime datetime = new DateTime(new Date(today.getTime() + oneDay));

  datetime.setDateOnly(true);

  return datetime;
}

public void createWebContent() throws Exception {
  URL feedUrl = new URL("http://www.google.com/calendar/feeds/default/private/full");

  CalendarEventEntry entry = new CalendarEventEntry();

  entry.setTitle(new PlainTextConstruct("create web content"));
  entry.setContent(new PlainTextConstruct("This event is created by Java client library"));

  DateTime startTime = getToday();
  DateTime endTime = getTomorrow();

  When eventTimes = new When();
  eventTimes.setStartTime(startTime);
  eventTimes.setEndTime(endTime);
  entry.addTime(eventTimes);

  WebContent wc = new WebContent();

  wc.setTitle("title");
  wc.setType("text/html");
  wc.setIcon("http://www.google.com/intl/en_ALL/images/logo.gif");
  wc.setUrl("http://www.google.com");
  wc.setWidth("800");
  wc.setHeight("600");

  entry.setWebContent(wc);

  // Send the request and receive the response:

  calendarService.insert(feedUrl, entry);
  System.out.println("Calendar Gadget is created");
}

Edit contact phone numbers using Python

2008-08-04T15:01:00.000-07:00

This sample shows the creation of a contact using the Google Contacts API. The phone number for the contact is then removed by editing the local contact entry object and uploading. At the ned, the script asks you to press enter before deleting the test contact.

import gdata.contacts.service
import atom
import gdata.contacts
import getpass

client = gdata.contacts.service.ContactsService()
client.email = raw_input('Please enter your email address')
client.password = getpass.getpass()
client.source = 'Google-ContactsGetTest-1.0'
client.ProgrammaticLogin()

name = 'Fred'
notes = 'Test entry'
primary_email = 'test2903488769871632@example.com'
new_contact = gdata.contacts.ContactEntry(title=atom.Title(text=name))
new_contact.content = atom.Content(text=notes)
new_contact.email.append(gdata.contacts.Email(address=primary_email,
                         primary='true', rel=gdata.contacts.REL_WORK))
new_contact.phone_number.append(gdata.contacts.PhoneNumber(
    rel=gdata.contacts.REL_OTHER, text='555-1212-3242'))
entry = client.CreateContact(new_contact)

if entry:
  print 'Creation successful!'
  print 'Edit link for the new contact:', entry.GetEditLink().href
else:
  print 'Upload error.'

# Remove the phone number
del entry.phone_number[0]

updated = client.UpdateContact(entry.GetEditLink().href, entry)
if updated:
  print 'Update successful!'
  print 'Edit link for the updated contact:', updated.GetEditLink().href
else:
  print 'Upload error.'

raw_input('enter to delete')
client.Delete(updated.GetEditLink().href)

Batch update spreadsheet cells using Python

2008-08-04T14:55:00.000-07:00

Using the gdata-python-client, you can change the value in multiple cells with one HTTP request. Here is an example:

import gdata.spreadsheet
import gdata.spreadsheet.service

client = gdata.spreadsheet.service.SpreadsheetsService()
client.email = 'your email address'
client.password = 'your password'
client.ProgrammaticLogin()

# Use the spreadsheet key and worksheet ID for the worksheet you want to edit.
cells = client.GetCellsFeed('pKq0C...', wksht_id='od6')

batchRequest = gdata.spreadsheet.SpreadsheetsCellsFeed()

# This sample changes the first four cells in the spreadsheet.
cells.entry[0].cell.inputValue = 'x'
batchRequest.AddUpdate(cells.entry[0])
cells.entry[1].cell.inputValue = 'y'
batchRequest.AddUpdate(cells.entry[1])
cells.entry[2].cell.inputValue = 'z'
batchRequest.AddUpdate(cells.entry[2])
cells.entry[3].cell.inputValue = '=sum(3,5)'
batchRequest.AddUpdate(cells.entry[3])

updated = client.ExecuteBatch(batchRequest, cells.GetBatchLink().href)

Printing out Video thumbnails for a user's upload feed

2008-07-31T13:22:00.000-07:00

A quick helper function to print thumbnails for all entries in a user's upload feed.

<php
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_YouTube');

function printThumbnails($username)
{
  $yt = new Zend_Gdata_YouTube();
  $userVideoFeed = $yt->getUserUploads($username);

  foreach($userVideoFeed as $videoEntry) {
    print "Thumbnails for entry $videoEntry->title ";
    $videoThumbnails = $videoEntry->getVideoThumbnails();
    foreach($videoThumbnails as $videoThumbnail) {
      echo $videoThumbnail['time'] . ' -- ' . 
        '<img src="' . $videoThumbnail['url']. '" height=' .
        $videoThumbnail['height'] . ' width=' . $videoThumbnail['width'] . ' />';
    }
  }
}
?>

Save A Google Docs Document As A File In .NET

2008-07-29T14:43:00.000-07:00

Given a DocumentEntry, save to local file "C:\example.html"

Uri documentUri = new Uri(entry.Content.AbsoluteUri);
Stream stream = service.Query(documentUri);
StreamReader streamReader = new StreamReader(stream);
StreamWriter streamWriter = new StreamWriter("C:\\example.html");
string line = "";
while( (line = streamReader.ReadLine()) != null) {
    streamWriter.WriteLine(line);
}
streamReader.Close();
streamWriter.Close();

Deleting Video Entrys based on Video ID and Developer Key

2008-07-28T12:59:00.001-07:00

A quick helper function explaining how to delete Video Entry's from YouTube based on a Developer Tag and based on an array of Video ID's to delete. Please note that this example assumes the use of the PHP Client Library.

/**
 * Delete a video matching a developer tag and a video id.
 *
 * @param $youTubeService Zend_Gdata_YouTube An authenticated YouTube service object.
 * @param $developerTag string A developer tag for which to retrieve videos.
 * @param $videoIdsToDelete array An array of video ids to be deleted.
 * @return void
 */
function deleteVideosByDeveloperTag($youTubeService, $developerTag, $videoIdsToDelete)
{
 $devTagUrl = 'http://gdata.youtube.com/feeds/videos/-/%7B' .
   'http%3A%2F%2Fgdata.youtube.com%2Fschemas%2F2007%2F' .
   'developertags.cat%7D' . $developerTag;

  $devTagFeed = $youTubeService->getVideoFeed($devTagUrl);

  foreach($developerTagFeed as $videoEntry) {
    if ($entry instanceof Zend_Gdata_YouTube_VideoEntry) {
      $videoIdsToBeDeleted[] = $videoEntry->getVideoId();
    }
  }

  // Then use a read-write feed to actually perform the deletion(s)
  $myVideoFeed = $youTubeService->getUserUploads('default');

  foreach($myVideoFeed as $videoEntry) {
    $id = $videoEntry->getVideoId();
     if (in_array($id, $videoIdsToBeDeleted) {
       $youTubeService->delete($videoEntry);
    }
  }
}

Labeling Blogger Posts

2008-07-27T22:33:00.000-07:00

When posting to Blogger, it's useful to organize your posts using using labels. When using the normal Blogger interface, this is done by adding a comma-separated list of labels to a text field at the bottom of the post. To achieve the same effect using the Blogger API, add an individual <atom:category> element for each label to your post's entry. Set the scheme to 'http://www.blogger.com/atom/ns#', and set the term to your desired label.

For example, the following code for the Zend_Gdata PHP client library would add the labels "foo" and "bar" to a post (stored in $entry):

$label1 = new Zend_Gdata_App_Extension_Category(
     'foo', 'http://www.blogger.com/atom/ns#');
$label2 = new Zend_Gdata_App_Extension_Category(
     'bar', 'http://www.blogger.com/atom/ns#');
$entry->setCategory(array($label1, $label2));

Secure AuthSub in PHP

2008-07-26T17:44:00.000-07:00

A helper for sending a signed HTTP GET request in PHP.

// upgrade a single-use AuthSub token
$response = signedGET('https://www.google.com/accounts/AuthSubSessionToken', $singleUseToken);

// fetch Calendar data
$response = signedGET('http://www.google.com/calendar/feeds/default/allcalendars/full', $sessionToken);

<?php
function signedGET($requestURL, $token) { 
  $privKeyFilePath = "../myrsakey.pem";
  $timestamp = time();
  $nonce = md5(microtime() . mt_rand()); 
  $sigalg = 'rsa-sha1';
  
  // construct the data string
  $data = "GET $requestURL $timestamp $nonce";
  
  // get rsa private key
  $fp = fopen($privKeyFilePath, "r");  
  $priv_key = fread($fp, 8192);
  fclose($fp);                                

  // compute signature
  $privatekeyid = openssl_get_privatekey($priv_key);
  openssl_sign($data, $signature, $privatekeyid, OPENSSL_ALGO_SHA1);
  openssl_free_key($privatekeyid);

  $curl = curl_init($requestURL);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_FAILONERROR, true);
  curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
  
  // Set Authorization header 
  $sig = base64_encode($signature);
  curl_setopt($curl, CURLOPT_HTTPHEADER, array(
      "Authorization: AuthSub token=\"$token\" data=\"$data\" sig=\"$sig\" sigalg=\"$sigalg\"")
  ); 
  
  $result = curl_exec($curl);
  curl_close($curl);

  return $result;
}
?>

Retrieving private Videos using the PHP Client Library

2008-07-18T12:12:00.000-07:00

To retrieve private videos you will need to pass the full URI of the video entry as the $location parameter to the getVideoEntry method. Assuming we have a fully authenticated YouTube service object as $service:

$videoIdOfPrivateVideo = 'ABC123xyz';
$location = 'http://gdata.youtube.com/feeds/api/users/default/uploads/' . $videoIdOfPrivateVideo;
$privateEntry = $youTubeService->getVideoEntry(null, $location);

Update: Version 1.7.1 and higher of the PHP Client Library has a new method "getFullVideoEntry()" that should take care of this.

Enable Request Debugging in PHP client library

2008-07-18T12:07:00.000-07:00

$service->enableRequestDebugLogging('/tmp/foo.txt');

Inject parameters into a string

2008-07-13T01:35:00.000-07:00

/* 
 * Formats a string with the given parameters. The string to format must have
 * placeholders that correspond to the index of the arguments passed and surrounded 
 * by curly braces (e.g. 'Some {0} string {1}').
 *
 * @param {string} var_args The string to be formatted should be the first 
 *     argument followed by the variables to inject into the string
 * @return {string} The string with the specified parameters injected
 */
format = function(var_args){
    var args = Array.prototype.slice.call(arguments, 1);
    return var_args.replace(/\{(\d+)\}/g, function(m, i){
        return args[i];
    });
};

format("Is it {0}->{1} or {1}->{0}?", "chicken", "egg") == "Is it chicken->egg or egg->chicken?"

JSON-in-script loader

2008-07-13T01:14:00.000-07:00


/**
 * Loads an external javascript source by creating a <script> tag
 * and injecting it into the DOM.
 * @param {string} src Url of the js source 
 * @param {string} opt_id An optional id for the <script> tag
 */ 
function load(src, opt_id) {
  var scripts = document.getElementsByTagName('script');
  
  // prevent from loading same script twice
  var alreadyLoaded = false;
  for (var i = 0, script; script = scripts[i]; i++) {
    if (script.src == src) {
      alreadyLoaded = true;
      break;
    }
  }
  
  if (!alreadyLoaded) {
    var scriptElement = document.createElement('script');
    if (opt_id) {
      scriptElement.setAttribute('id', opt_id);
    }
    scriptElement.setAttribute('type', 'text/javascript');
    scriptElement.setAttribute('src', src);
    document.documentElement.firstChild.appendChild(scriptElement);
  }
};

SimpleXML and accessing MediaRSS / other namespaces

2008-07-11T15:40:00.001-07:00

print_r($xml->getDocNamespaces());

foreach ($xml->entry as $entry)
{

  //All the media namespaced items under an entry
  $media = $entry->children("http://search.yahoo.com/mrss/%27%29;"');
  echo "Title: " . $media->group->title;
  echo "Keywords: " . $media->group->keywords;

  //There are multiple thumbnail fields, so loop through and print out
  all the attributes
  foreach($media->group->thumbnail as $thumb)
  {
    foreach ($thumb->attributes() as $a => $b)
    {
      print $a . " " . $b . "\n";
    }
  }
}

Fetch a Google Data feed using PHP & Curl

2008-07-11T14:38:00.000-07:00

As a continuation from my last post, here's how you get a feed.

<?
// Note: this function assumes secure=0 AuthSub tokens
function getFeed($feedUri, $sessionToken) {
  $curl = curl_init($feedUri);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_HTTPHEADER, array(
    'Content-Type: application/atom+xml',
    'Authorization: AuthSub token="' . trim($sessionToken) . '"'
  ));
  $response = curl_exec($curl);

  if (!$response) {
    die('Error: ' . curl_error($curl) . "\n");
  }
  curl_close($curl);
  
  return $response;
}
?>

AuthSub using PHP's libcurl

2008-07-11T14:11:00.000-07:00


<?
$secure = 0;
$session = 1;
$scope = 'http://www.google.com/calendar/feeds';
$next = "http://{$_SERVER['HTTP_HOST']}{$_SERVER['PHP_SELF']}";

$token = @$_GET['token'];  // only a single use token

if(!$token) {
 echo "<a href=\"https://www.google.com/accounts/AuthSubRequest?scope=$scope&session=$session&secure=$secure&next=$next\">Sign in to Google</a>";
 exit;
}

$sessionToken = upgradeToken($token);
echo "Single use token: $token\n";
echo "Session token: $sessionToken";

// TODO: get a feed

function upgradeToken($token) {
  $ch = curl_init("https://www.google.com/accounts/AuthSubSessionToken");
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_FAILONERROR, true);
  curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: AuthSub token="' . trim($token) . '"'
  ));

  $result = curl_exec($ch);
  curl_close($ch);

  $splitStr = split("=", $result);

  return trim($splitStr[1]);
}
?>

Access Spreadsheets list feed elements in Python

2008-07-09T10:54:00.000-07:00

# print out dictionary of row information for each row
for entry in worksheet_list_feed.entry:
  for key in entry.custom:
    print '%s: %s' % (key, entry.custom[key].text)

Signed AuthSub in Ruby

2008-07-03T10:32:00.000-07:00

Example code for signing an AuthSub request in Ruby. Contributed by an awesome guy named Immad. Watch out for the groups linebreak in his line that starts with header =, though.

GoDaddy SSL Proxy with Zend Framework

2008-07-03T10:25:00.000-07:00

$client = new Zend_Http_Client('https://www.example.com/', array(
       'adapter'      => 'Zend_Http_Client_Adapter_Proxy',
       'proxy_host'   => 'proxy.shr.secureserver.net',
       'proxy_port'   => 3128
)); 

        $sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken($singleUseToken, $client);

This can also be used with ClientLogin:

$clientLoginClient = Zend_Gdata_ClientLogin::getHttpClient($email, $passwd, 'cl', $client);