PHP5

The Google Calendar API allows access to both public and private calendar feeds. Public feeds do not require authentication, but are read-only and offer reduced functionality. Private feeds offers the most complete functionality but requires an authenticated connection to the calendar servers. There are three authentication schemes that are supported by Google Calendar:

The Zend_Gdata library provides support for both authentication schemes. The rest of this chapter will assume that you are familiar the authentication schemes available and how to create an appropriate authenticated connection. For more information, please see section the Authentication section of this manual or the Authentication Overview in the Google Data API Developer's Guide.

In order to interact with the servers, this library provides the Zend_Gdata_Photos service class. This class provides a common interface to the Google Data and Atom Publishing Protocol models and assists in marshaling requests to and from the servers.

Once deciding on an authentication scheme, the next step is to create an instance of Zend_Gdata_Photos. The class constructor takes an instance of Zend_Http_Client as a single argument. This provides an interface for AuthSub and ClientAuth authentication, as both of these require creation of a special authenticated HTTP client. If no arguments are provided, an unauthenticated instance of Zend_Http_Client will be automatically created.

The example below shows how to create a service class using ClientAuth authentication:

<?php
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Photos');
Zend_Loader::loadClass('Zend_Http_Client');

// Parameters for ClientAuth authentication
$service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
$user = "sample.user@gmail.com";
$pass = "pa$$w0rd";

// Create an authenticated HTTP client
$client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);

// Create an instance of the service
$service = new Zend_Gdata_Photos($client);
            

A service instance using AuthSub can be created in a similar, though slightly more lengthy fashion:

<?php
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_AuthSub');
Zend_Loader::loadClass('Zend_Gdata_Photos');
Zend_Loader::loadClass('Zend_Http_Client');

session_start();

/**
 * Returns the full URL of the current page, based upon env variables
 * 
 * Env variables used:
 * $_SERVER['HTTPS'] = (on|off|)
 * $_SERVER['HTTP_HOST'] = value of the Host: header
 * $_SERVER['SERVER_PORT'] = port number (only used if not http/80,https/443)
 * $_SERVER['REQUEST_URI'] = the URI after the method of the HTTP request
 *
 * @return string Current URL
 */
function getCurrentUrl() 
{
    global $_SERVER;

    /**
     * Filter php_self to avoid a security vulnerability.
     */
    $php_request_uri = htmlentities(substr($_SERVER['REQUEST_URI'], 0,
    strcspn($_SERVER['REQUEST_URI'], "\n\r")), ENT_QUOTES);

    if (isset($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) == 'on') {
        $protocol = 'https://';
    } else {
        $protocol = 'http://';
    }
    $host = $_SERVER['HTTP_HOST'];
    if ($_SERVER['SERVER_PORT'] != '' &&
        (($protocol == 'http://' && $_SERVER['SERVER_PORT'] != '80') ||
        ($protocol == 'https://' && $_SERVER['SERVER_PORT'] != '443'))) {
            $port = ':' . $_SERVER['SERVER_PORT'];
    } else {
        $port = '';
    }
    return $protocol . $host . $port . $php_request_uri;
}

/**
 * Returns the AuthSub URL which the user must visit to authenticate requests 
 * from this application.
 *
 * Uses getCurrentUrl() to get the next URL which the user will be redirected
 * to after successfully authenticating with the Google service.
 *
 * @return string AuthSub URL
 */
function getAuthSubUrl() 
{
    $next = getCurrentUrl();
    $scope = 'http://picasaweb.google.com/data';
    $secure = false;
    $session = true;
    return Zend_Gdata_AuthSub::getAuthSubTokenUri($next, $scope, $secure, 
        $session);
}

/**
 * Returns a HTTP client object with the appropriate headers for communicating
 * with Google using AuthSub authentication.
 *
 * Uses the $_SESSION['sessionToken'] to store the AuthSub session token after
 * it is obtained.  The single use token supplied in the URL when redirected 
 * after the user succesfully authenticated to Google is retrieved from the 
 * $_GET['token'] variable.
 *
 * @return Zend_Http_Client
 */
function getAuthSubHttpClient() 
{
    global $_SESSION, $_GET;
    if (!isset($_SESSION['sessionToken']) && isset($_GET['token'])) {
        $_SESSION['sessionToken'] = 
            Zend_Gdata_AuthSub::getAuthSubSessionToken($_GET['token']);
    } 
    $client = Zend_Gdata_AuthSub::getHttpClient($_SESSION['sessionToken']);
    return $client;
}

/**
 * Create a new instance of the service, redirecting the user
 * to the AuthSub server if necessary.
 */
$service = new Zend_Gdata_Photos(getAuthSubHttpClient());
            

Finally, an unauthenticated server can be created for use with public feeds:

<?php
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Photos');

// Create an instance of the service using an unauthenticated HTTP client

$service = new Zend_Gdata_Photos();
            

The service supports retrieving a user feed and list of the user's content. If the requested user is also the authenticated user, entries marked as "hidden" will also be returned.

The user feed can be accessed by passing the username to the getUserFeed method:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    try {
        $userFeed = $service->getUserFeed("sample.user");
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

Or, the feed can be accessed by constructing a query, first:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_UserQuery();
    $query->setUser("sample.user");

    try {
        $userFeed = $service->getUserFeed(null, $query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

Constructing a query also provides the ability to request a user entry object:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_UserQuery();
    $query->setUser("sample.user");
    $query->setType("entry");

    try {
        $userEntry = $service->getUserEntry($query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

The service supports retrieving an album feed and a list of the album's content.

The album feed is accessed by constructing a query object and passing it to getAlbumFeed:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_AlbumQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");

    try {
        $albumFeed = $service->getAlbumFeed($query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

Alternatively, the query object can be given an album name with setAlbumName. Setting the album name is mutually exclusive with setting the album id, and setting one will unset the other.

Constructing a query also provides the ability to request an album entry object:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_AlbumQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");
    $query->setType("entry");

    try {
        $albumEntry = $service->getAlbumEntry($query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

The service supports retrieving a photo feed and a list of associated comments and tags.

The photo feed is accessed by constructing a query object and passing it to getPhotoFeed:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_PhotoQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");
    $query->setPhotoId("100");

    try {
        $photoFeed = $service->getPhotoFeed($query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

Constructing a query also provides the ability to request a photo entry object:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_PhotoQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");
    $query->setPhotoId("100");
    $query->setType("entry");

    try {
        $photoEntry = $service->getPhotoEntry($query);
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

The service supports retrieving comments from a feed of a different type. By setting a query to return a kind of "comment", a feed request can return comments associated with a specific user, album, or photo.

Performing an action on each of the comments on a given photo can be accomplished as follows:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_PhotoQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");
    $query->setPhotoId("100");
    $query->setKind("comment");

    try {
        $photoFeed = $service->getPhotoFeed($query);
    
        foreach ($photoFeed as $entry) {
            if ($entry instanceof Zend_Gdata_Photos_CommentEntry) {
                // Do something with the comment
            }
        }
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

The service supports retrieving tags from a feed of a different type. By setting a query to return a kind of "tag", a feed request can return tags associated with a specific photo.

Performing an action on each of the tags on a given photo can be accomplished as follows:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $query = new Zend_Gdata_Photos_PhotoQuery();
    $query->setUser("sample.user");
    $query->setAlbumId("1");
    $query->setPhotoId("100");
    $query->setKind("tag");

    try {
        $photoFeed = $service->getPhotoFeed($query);
    
        foreach ($photoFeed as $entry) {
            if ($entry instanceof Zend_Gdata_Photos_TagEntry) {
                // Do something with the tag
            }
        }
    } catch (Zend_Gdata_App_Exception $e) {
        echo "Error: " . $e->getResponse();
    }
            

The service supports creating a new album for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $entry = new Zend_Gdata_Photos_AlbumEntry();
    $entry->setTitle($service->newTitle("test album"));

    $service->insertAlbumEntry($entry);
            

The service supports creating a new photo for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    // $photo is the name of a file uploaded via an HTML form

    $fd = $service->newMediaFileSource($photo["tmp_name"]);
    $fd->setContentType($photo["type"]);

    $entry = new Zend_Gdata_Photos_PhotoEntry();
    $entry->setMediaSource($fd);
    $entry->setTitle($service->newTitle($photo["name"]));

    $albumQuery = new Zend_Gdata_Photos_AlbumQuery;
    $albumQuery->setUser("sample.user");
    $albumQuery->setAlbumId("1");

    $albumEntry = $service->getAlbumEntry($albumQuery);

    $service->insertPhotoEntry($entry, $albumEntry);
            

The service supports creating a new comment for a photo:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $entry = new Zend_Gdata_Photos_CommentEntry();
    $entry->setTitle($service->newTitle("comment"));
    $entry->setContent($service->newContent("comment"));

    $photoQuery = new Zend_Gdata_Photos_PhotoQuery;
    $photoQuery->setUser("sample.user");
    $photoQuery->setAlbumId("1");
    $photoQuery->setPhotoId("100");
    $photoQuery->setType('entry');

    $photoEntry = $service->getPhotoEntry($photoQuery);

    $service->insertCommentEntry($entry, $photoEntry);
            

The service supports creating a new tag for a photo:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $entry = new Zend_Gdata_Photos_TagEntry();
    $entry->setTitle($service->newTitle("tag"));

    $photoQuery = new Zend_Gdata_Photos_PhotoQuery;
    $photoQuery->setUser("sample.user");
    $photoQuery->setAlbumId("1");
    $photoQuery->setPhotoId("100");
    $photoQuery->setType('entry');

    $photoEntry = $service->getPhotoEntry($photoQuery);

    $service->insertTagEntry($entry, $photoEntry);
            

The service supports deleting an album for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $albumQuery = new Zend_Gdata_Photos_AlbumQuery;
    $albumQuery->setUser("sample.user");
    $albumQuery->setAlbumId("1");
    $albumQuery->setType('entry');

    $entry = $service->getAlbumEntry($albumQuery);

    $service->deleteAlbumEntry($entry, true);
            

The service supports deleting a photo for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $photoQuery = new Zend_Gdata_Photos_PhotoQuery;
    $photoQuery->setUser("sample.user");
    $photoQuery->setAlbumId("1");
    $photoQuery->setPhotoId("100");
    $photoQuery->setType('entry');

    $entry = $service->getPhotoEntry($photoQuery);

    $service->deletePhotoEntry($entry, true);
            

The service supports deleting a comment for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $photoQuery = new Zend_Gdata_Photos_PhotoQuery;
    $photoQuery->setUser("sample.user");
    $photoQuery->setAlbumId("1");
    $photoQuery->setPhotoId("100");
    $photoQuery->setType('entry');

    $path = $photoQuery->getQueryUrl() . '/commentid/' . "1000";

    $entry = $service->getCommentEntry($path);

    $service->deleteCommentEntry($entry, true);
            

The service supports deleting a tag for an authenticated user:

<?php
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
    $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
    $service = new Zend_Gdata_Photos($client);

    $photoQuery = new Zend_Gdata_Photos_PhotoQuery;
    $photoQuery->setUser("sample.user");
    $photoQuery->setAlbumId("1");
    $photoQuery->setPhotoId("100");
    $photoQuery->setKind("tag");
    $query = $photoQuery->getQueryUrl();

    $photoFeed = $service->getPhotoFeed($query);

    foreach ($photoFeed as $entry) {
        if ($entry instanceof Zend_Gdata_Photos_TagEntry) {
            if ($entry->getContent() == $tagContent) {
                $tagEntry = $entry;
            }
        }
    }

    $service->deleteTagEntry($tagEntry, true);
            

GData feeds, including those of the Picasa Web Albums service, implement optimistic concurrency, a versioning system that prevents users from overwriting changes, inadvertently. When deleting a entry through the service class, if the entry has been modified since it was last fetched, an exception will be thrown, unless explicitly set otherwise (in which case the deletion is retried on the updated entry).

An example of how to handle versioning during a deletion is shown by deleteAlbumEntry:

<?php
    // $album is the albumEntry to be deleted
    try {
        $this->delete($album);
    } catch (Zend_Gdata_App_HttpException $e) {
        if ($e->getResponse->getStatus() === 409) {
            $entry = new Zend_Gdata_Photos_AlbumEntry($e->getResponse()->getBody());
            $this->delete($entry->getLink('edit')->href);
        } else {
            throw $e;
        }
    }