repo_zf1/documentation/manual/fr/module_specs/Zend_Gdata_Photos.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect1 id="zend.gdata.photos">
    <title>Utilisation des albums Web Picasa</title>

    <para>
        Les albums Web Picasa représentent un service Google permettant de maintenir à jour
        des albums photos, tout en pouvant récupérer des photos de l'album d'un membre. L'API
        propose des services pour ajouter, mettre à jour ou supprimer des photos d'un album, de même
        que gérer des mots-clés ou des commentaires sur des images(photos).
    </para>

    <para>
        L'accès public à un album, en lecture donc, n'est pas sujet à demande
        d'authentification. En revanche, toute autre manipulation telle que la mise à jour ou la
        suppression, nécessitera que vous vous authentifiez.
    </para>

    <para>
        Pour plus d'informations sur l'API, voyez <ulink
        url="http://code.google.com/apis/picasaweb/overview.html">l'API Picasa Web
        Albums</ulink>.
    </para>

    <note>
        <title>Authentification</title>

        <para>
            L'API propose les deux modes d'authentification, AuthSub (recommandé) et
            ClientAuth. Pour toute opération d'écriture vers le service, une authentification sera
            demandée, la lecture est elle, libre, au regard de l'API.
        </para>
    </note>

    <sect2 id="zend.gdata.photos.connecting">
        <title>Se connecter au service</title>

        <para>
            L'API Picasa, comme tous les autres services Web Google Gdata, est basée sur le
            protocole Atom Publishing Protocol (APP), et le <acronym>XML</acronym>. Le trafic entre le client et le
            serveur se fait sur <acronym>HTTP</acronym>, et autorise des connexions authentifiées, ou non.
        </para>

        <para>
            Avant tout, il faut donc se connecter. Ceci se fait en deux étapes : créer un
            client <acronym>HTTP</acronym>, et insérer un <classname>Zend_Gdata_Photos</classname> dans
            celui-ci.
        </para>

        <sect3 id="zend.gdata.photos.connecting.authentication">
            <title>Authentification</title>

            <para>
                L'API propose un accès à la fois aux données publiques, et aux données
                privées. Les données publiques ne requièrent pas d'authentification, mais ne sont
                accessibles qu'en lecture seule. L'écriture et l'accès aux données privées
                requièrent une authentification, qui peut s'effectuer de trois manières différentes
                :
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <firstterm>ClientAuth</firstterm> permet une authentification directe
                        en donnant un couple login/password. Les utilisateurs devront donc
                        renseigner ces 2 paramètres sur votre site directement.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <firstterm>AuthSub</firstterm> permet l'authentification en passant
                        par un serveur proxy de Google. Les risques liés à la sécurité sont donc
                        moindre avec cette méthode.
                    </para>
                </listitem>
            </itemizedlist>

            <para>
                La librairie <classname>Zend_Gdata</classname> permet ces 2 types
                d'authentification. Le reste de ce chapitre supposera que vous soyez habitué à
                l'authentification avec les service Web Google GData. Si ce n'est pas le cas, nous
                vous conseillons de consulter <link
                linkend="zend.gdata.introduction.authentication">la section authentification</link>
                de ce manuel, ou encore <ulink url="http://code.google.com/apis/gdata/auth.html">le
                guide d'authentification Google GData webservices <acronym>API</acronym></ulink>.
            </para>
        </sect3>

        <sect3 id="zend.gdata.photos.connecting.service">
            <title>Créer une instance du service</title>

            <para>
                Pour interagir avec les serveurs, la classe
                <classname>Zend_Gdata_Photos</classname> sera nécessaire. Elle abstrait toute la
                logique de communication avec le Protocol Atom Publishing vers les serveurs de
                Google.
            </para>

            <para>
                Une fois que vous avez choisi une méthode d'authentification, vous devez créer
                une instance de <classname>Zend_Gdata_Photos</classname>. Le constructeur prend en
                paramètre une instance de <classname>Zend_Http_Client</classname>. Cette classe est
                l'interface AuthSub ou ClientAuth authentification. Si vous ne passez pas cette
                instance en argument, alors une instance de <classname>Zend_Http_Client</classname>
                sera crée automatiquement, mais en mode non authentifié.
            </para>

            <para>
                Voici un exemple qui démontre comment créer une classe vers le service avec le
                procédé d'authentification ClientAuth :
            </para>

            <programlisting language="php"><![CDATA[
// Paramètres pour ClientAuth authentification
$service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
$user = "sample.user@gmail.com";
$pass = "pa$$w0rd";

// Création d'une client HTTP authentifié
$client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);

// Création de l'instance du service
$service = new Zend_Gdata_Photos($client);
]]></programlisting>

            <para>Au sujet du procédé AuthSub, voici la démarche :</para>

            <programlisting language="php"><![CDATA[
session_start();

/**
 * Retourne l'URL complet de la page actuelle,
 * en fonction des variables d'environnement
 *
 * Env variables utilisées:
 * $_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;

    /**
     * Filtre php_self pour éviter des problèmes de sécurité
     */
    $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;
}

/**
 * Retourne l'URL AuthSub que l'utilisateur doit visiter
 * pour authentifier ses requêtes
 *
 * Utilise getCurrentUrl() pour récupérer le prochain URL
 * vers lequel l'utilisateur sera redirigé après
 * s'être authentifié.
 *
 * @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);
}

/**
 * Retourne un objet servant de client HTTP avec les bons en-têtes,
 * permettant de communiquer avec les services Google, et utilisant
 * l'authentification AuthSub.
 *
 * Utilise $_SESSION['sessionToken'] pour stocker le jeton de session
 * AuthSub après l'avoir obtenu. $_GET['token'] récupère ce jeton
 * après la redirection d'authentification
 *
 * @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;
}

/**
 * Créer une instance du service, redirigeant l'utilisateur
 * vers le serveur AuthSub si nécéssaire.
 */
$service = new Zend_Gdata_Photos(getAuthSubHttpClient());
]]></programlisting>

            <para>Enfin, un client non authentifié peut aussi être crée :</para>

            <programlisting language="php"><![CDATA[
// Création d'une instance du service en mode non authentifié
$service = new Zend_Gdata_Photos();
]]></programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.gdata.photos.queries">
        <title>Comprendre et construire des requêtes</title>

        <para>
            Pour créer des requêtes vers le service Web, vous devrez utiliser une de ces
            classes :
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <firstterm>User</firstterm> Cette classe requêtera tout ce qui concerne un
                    utilisateur du service. Sans spécifier d'utilisateur, "default" sera
                    utilisé.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Album</firstterm> Cette classe va servir de base pour toutes
                    les requêtes concernant les albums Picasa.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Photo</firstterm> Cette classe va servir de base pour toutes
                    les requêtes concernant les photos Picasa.
                </para>
            </listitem>
        </itemizedlist>

        <para>Une <code>UserQuery</code> peut être construite comme suit :</para>

        <programlisting language="php"><![CDATA[
$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");
]]></programlisting>

        <para>
            Pour chaque requête, des paramètres de limitations de la recherche peuvent être
            passés grâce aux méthodes get(Paramètre) and set(Paramètre) :
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <firstterm>Projection</firstterm> spécifie le format de retour des données
                    dans le flux. Peut être "api" ou "base". En temps normal, "api" est conseillé,
                    c'est la valeur par défaut d'ailleurs.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Type</firstterm> détermine le type des éléments retournés,
                    "feed"(défaut) ou "entry".
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Access</firstterm> détermine la visibilité des éléments
                    retournés, "all"(défaut), "public", ou "private". Les éléments non publics ne
                    seront retournés que si le client est authentifié.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Tag</firstterm> fournit un filtre par mots-clés sur les
                    éléments retournés.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Kind</firstterm> détermine un filtre sur la sorte (le type)
                    d'éléments retournés.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>ImgMax</firstterm> spécifie un filtre par dimension maximale
                    sur les éléments retournés.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>Thumbsize</firstterm> spécifie un filtre par dimension maximale
                    des miniatures retournées.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>User</firstterm> spécifie l'utilisateur dont les éléments sont
                    recherchés. Par défaut, "default".
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>AlbumId</firstterm> spécifie l'identifiant de l'album
                    recherché. Ceci ne s'applique qu'aux requêtes album et photo. Dans le cas d'une
                    recherche de photo, ceci indique l'album dans lequel effectuer la requête de
                    recherche. Ce paramètre annule et remplace AlbumName, si spécifié.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>AlbumName</firstterm> spécifie le nom de l'album recherché.
                    Ceci ne s'applique qu'aux requêtes album et photo. Dans le cas d'une recherche
                    de photo, ceci indique l'album dans lequel effectuer la requête de recherche. Ce
                    paramètre annule et remplace AlbumId, si spécifié.
                </para>
            </listitem>

            <listitem>
                <para>
                    <firstterm>PhotoId</firstterm> spécifie l'identifiant de la photo
                    recherchée. Ceci ne s'applique qu'aux requêtes photo.
                </para>
            </listitem>
        </itemizedlist>
    </sect2>

    <sect2 id="zend.gdata.photos.retrieval">
        <title>Récupérer des flux et des éléments</title>

        <para>
            Le service propose des méthodes de récupération de flux, ou d'éléments simples,
            concernant les utilisateurs, albums, ou photos.
        </para>

        <sect3 id="zend.gdata.photos.user_retrieval">
            <title>Récupérer un utilisateur</title>

            <para>
                Le service propose de récupérer un utilisateur, et toutes les infos de son
                flux, comme ses photos, ses albums.... Si le client est authentifié et demande des
                informations sur son propre compte, alors les éléments marqués comme
                "<code>hidden</code>" seront aussi retournés.
            </para>

            <para>
                Le flux de l'utilisateur est accessible en passant son nom à la méthode
                <code>getUserFeed</code> :
            </para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>

            <para>Ou alors, le flux peut être requêté directement :</para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>

            <para>
                Construire une requête donne aussi accès aux éléments d'un utilisateur
                :
            </para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.album_retrieval">
            <title>Récupérer un album</title>

            <para>Le service donne accès aux flux d'albums et à leurs contenus.</para>

            <para>
                Le flux d'albums est disponible en construisant un objet de requête et en le
                passant à <code>getAlbumFeed</code> :
            </para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>

            <para>
                L'objet de requête accepte aussi un nom d'album avec
                <code>setAlbumName</code>. Attention, ceci annule un identifiant d'album
                éventuellement précédemment spécifié.
            </para>

            <para>Construire une requête donne aussi accès au requêtage d'un album :</para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.photo_retrieval">
            <title>Récupérer une Photo</title>

            <para>
                Le service permet la récupération de flux de photos, et des commentaires et/ou
                mots-clés associés
            </para>

            <para>
                Le flux de photos est accessible en construisant un objet de requête et en le
                passant à la méthode <code>getPhotoFeed</code> :
            </para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>

            <para>Construire une requête donne aussi accès au requêtage d'une photo :</para>

            <programlisting language="php"><![CDATA[
    $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->getMessage();
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.comment_retrieval">
            <title>Récupérer des commentaires</title>

            <para>
                Vous pouvez récupérer des commentaires depuis des éléments divers de flux. En
                spécifiant à votre requête un paramètre de "comment", celle-ci retournera les
                mots-clés associés à la ressource demandée (user, album ou photo)
            </para>

            <para>
                Voici comment effectuer des actions sur les commentaires récupérés d'une photo
                :
            </para>

            <programlisting language="php"><![CDATA[
    $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) {
            // Faites quelque chose avec le commentaire
        }
    }
} catch (Zend_Gdata_App_Exception $e) {
    echo "Error: " . $e->getMessage();
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.tag_retrieval">
            <title>Récupérer des mots-clés</title>

            <para>
                Vous pouvez récupérer des mots-clés depuis des éléments divers de flux. En
                spécifiant à votre requête un paramètre de "tag", celle-ci retournera les mots-clés
                associés à la ressource demandée.
            </para>

            <para>
                Voici comment effectuer des actions sur les mots-clés récupérés d'une photo
                :
            </para>

            <programlisting language="php"><![CDATA[
    $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) {
            // Faites quelque chose avec le mot-clé
        }
    }
} catch (Zend_Gdata_App_Exception $e) {
    echo "Error: " . $e->getMessage();
}
]]></programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.gdata.photos.creation">
        <title>Créer des ressources</title>

        <para>
            Des opérations de création sont possible, qu'il s'agisse d'albums, photos,
            commentaires, ou mots-clés.
        </para>

        <sect3 id="zend.gdata.photos.album_creation">
            <title>Créer un album</title>

            <para>Il est possible de créer un album, pour les clients authentifiés :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.photo_creation">
            <title>Créer une photo</title>

            <para>
                Créer une photo est possible pour les clients authentifiés, procédez comme
                suit :
            </para>

            <programlisting language="php"><![CDATA[
    $service = Zend_Gdata_Photos::AUTH_SERVICE_NAME;
$client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
$service = new Zend_Gdata_Photos($client);

// $photo est le nom d'un fichier issu d'un formulaire d'uplaod

$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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.comment_creation">
            <title>Créer un commentaire pour une photo</title>

            <para>
                Il est possible de créer un commentaire pour une photo, voici un exemple
                :
            </para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.tag_creation">
            <title>Créer un mot-clé pour une photo</title>

            <para>Il est possible de créer un mot-clé pour une photo, voici un exemple :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.gdata.photos.deletion">
        <title>Supprimer des éléments</title>

        <para>Il est possible de supprimer albums, photos, commentaires, et mots-clés.</para>

        <sect3 id="zend.gdata.photos.album_deletion">
            <title>Supprimer un album</title>

            <para>Supprimer un album est possible si le client est authentifié :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.photo_deletion">
            <title>Supprimer une photo</title>

            <para>Supprimer une photo est possible si le client est authentifié :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.comment_deletion">
            <title>Supprimer un commentaire</title>

            <para>Supprimer un commentaire est possible si le client est authentifié :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.tag_deletion">
            <title>Supprimer un mot-clé</title>

            <para>Supprimer un mot-clé est possible, si le client est authentifié :</para>

            <programlisting language="php"><![CDATA[
    $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);
]]></programlisting>
        </sect3>

        <sect3 id="zend.gdata.photos.optimistic_concurrenty">
            <title>Gestion des accès concurrents</title>

            <para>
                Les flux GData, dont ceux de Picasa Web Albums, implémentent un système
                d'accès concurrent qui empêche les changements avec écrasements par inadvertance. Si
                vous demandez l'effacement d'une ressource qui a été modifiée depuis votre dernière
                requête, alors une exception sera levée, sauf si vous demandez le contraire
                explicitement (dans un tel cas, la procédure d'effacement sera réessayée sur
                l'élément mis à jour).
            </para>

            <para>
                Voici un exemple de gestion des versions et accès concurrent sur un effacement
                avec <code>deleteAlbumEntry</code>:
            </para>

            <programlisting language="php"><![CDATA[
    // $album est l'albumEntry à effacer
try {
    $this->delete($album);
} catch (Zend_Gdata_App_HttpException $e) {
    if ($e->getMessage()->getStatus() === 409) {
        $entry =
            new Zend_Gdata_Photos_AlbumEntry($e->getMessage()
                                               ->getBody());
        $this->delete($entry->getLink('edit')->href);
    } else {
        throw $e;
    }
}
]]></programlisting>
        </sect3>
    </sect2>
</sect1>