Timeline: patch

Requer autorização

Atualiza um item da linha do tempo. Esse método é compatível com a semântica de patch. Veja um exemplo.

Solicitação

Solicitação HTTP

PATCH https://www.googleapis.com/mirror/v1/timeline/id

Parâmetros

Nome do parâmetro	Valor	Descrição
Parâmetros de caminho
id	string	ID do item de linha do tempo.

Autorização

Esta solicitação requer autorização com pelo menos um dos seguintes escopos (leia mais sobre autenticação e autorização).

Escopo
https://www.googleapis.com/auth/glass.timeline
https://www.googleapis.com/auth/glass.location

Corpo da solicitação

No corpo da solicitação, forneça as partes relevantes de um recurso Timeline, de acordo com as regras de semântica de patch.

Resposta

Se for bem-sucedido, este método retornará um recurso Timeline no corpo da resposta.

Exemplos

Observação: os exemplos de código disponíveis para esse método não representam todas as linguagens de programação compatíveis. Consulte a página de bibliotecas cliente para ver uma lista de linguagens compatíveis.

Java

Usa a biblioteca cliente de Java.

import com.google.api.services.mirror.Mirror;
import com.google.api.services.mirror.model.TimelineItem;

import java.io.IOException;

public class MyClass {
  // ...

  /**
   * Update the text of an existing timeline item.
   * 
   * @param service Authorized Mirror service.
   * @param itemId ID of the timeline item to update.
   * @param newText New text content for the timeline item.
   * @return Updated timeline item on success, {@code null} otherwise.
   */
  public static TimelineItem patchTimelineItem(Mirror service, String itemId, String newText) {
    TimelineItem patchedTimelineItem = new TimelineItem();
    patchedTimelineItem.setText(newText);
    try {
      return service.timeline().patch(itemId, patchedTimelineItem).execute();
    } catch (IOException e) {
      System.err.println("An error occurred: " + e);
      return null;
    }
  }

  // ...
}

.NET

Usa a biblioteca do cliente.NET.

using System;

using Google.Apis.Mirror.v1;
using Google.Apis.Mirror.v1.Data;

public class MyClass {
  // ...

  /// <summary>
  /// Update the text of an existing timeline item.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='itemId'>ID of the timeline item to update.</param>
  /// <param name='newText'>
  /// New text content for the timeline item.
  /// </param>
  /// <returns>
  /// Updated timeline item on success, null otherwise.
  /// </returns>
  public static TimelineItem PatchTimelineItem(MirrorService service,
      String itemId, String newText) {
    TimelineItem patchedTimelineItem = new TimelineItem() {
      Text = newText
    };
    try {
      return service.Timeline.Patch(patchedTimelineItem, itemId).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Usa a biblioteca cliente de PHP.

/**
 * Update the text of an existing timeline item.
 *
 * @param Google_MirrorService $service Authorized Mirror service.
 * @param string $itemId ID of the timeline item to update.
 * @param string $newText New text content for the timeline item.
 * @return Google_TimelineItem Updated timeline item on success,
 *         null otherwise.
 */
function patchTimelineItem($service, $itemId, $newText) {
  try {
    $patchedTimelineItem = new Google_TimelineItem();
    $patchedTimelineItem->setText($text);
    return $service->timeline->patch($itemId, $patchedTimelineItem);
  } catch (Exception $e) {
    print 'An error occurred: ' . $e->getMessage();
    return null;
  }
}

Python

Usa a biblioteca cliente de Python.

from apiclient import errors
# ...

def patch_timeline_item(service, item_id, new_text):
  """Update the text of an existing timeline item.

  Args:
    service: Authorized Mirror service.
    item_id: ID of the timeline item to update.
    new_text: New text content for the timeline item.

  Returns:
    Updated timeline item on success, None otherwise.
  """
  patched_timeline_item = {'text': new_text}
  try:
    return service.timeline().patch(
        id=item_id, body=patched_timeline_item).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Ruby

Usa a biblioteca de cliente Ruby.

##
# Update the text of an existing Timeline Item.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] item_id
#   ID of the timeline item to update.
# @param [String] new_text
#   New text content for the timeline item.
# @return [Google::APIClient::Schema::Mirror::V1::TimelineItem]
#    Updated timeline item on success, nil otherwise.
def patch_timeline_item(client, item_id, new_text)
  mirror = client.discovered_api('mirror', 'v1')
  result = client.execute(
    :api_method => mirror.timeline.patch,
    :body_object => { 'text' => new_text },
    :parameters => { 'id' => item_id })
  if result.success?
    return result.data
  end
  puts "An error occurred: #{result.data['error']['message']}"
end

Go

Usa a biblioteca de cliente Go.

import (
	"code.google.com/p/google-api-go-client/mirror/v1"
	"fmt"
)

// PatchTimelineItem updates the text of an existing timeline item.
func PatchTimelineItem(g *mirror.Service, itemId string, newText string) (
	*mirror.TimelineItem, error) {
	t := &mirror.TimelineItem{Text: newText}
	r, err := g.Timeline.Patch(itemId, t).Do()
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
		return nil, err
	}
	return r, nil
}

HTTP bruto

Não usa uma biblioteca de cliente.

PATCH /mirror/v1/timeline/timeline item id HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer auth token
Content-Type: application/json
Content-Length: 26

{ "text": "Hello world" }