Timeline: patch

Autorisierung erforderlich

Aktualisiert ein Zeitachsenelement. Diese Methode unterstützt die Patch-Semantik. Beispiel ansehen

Anfrage

HTTP-Anfrage

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

Parameter

Parametername Wert Beschreibung
Pfadparameter
id string Die ID des Zeitachsenelements.

Autorisierung

Diese Anfrage benötigt eine Autorisierung mit mindestens einem der folgenden Bereiche (weitere Informationen zu Authentifizierung und Autorisierung).

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

Anfragetext

Geben Sie im Anfragetext die relevanten Teile einer Zeitachsenressource nach den Regeln der Patch-Semantik an.

Antwort

Wenn der Vorgang erfolgreich ist, wird mit dieser Methode eine Zeitachsenressource im Antworttext zurückgegeben.

Beispiele

Hinweis: Bei den für diese Methode verfügbaren Codebeispielen sind nicht alle unterstützten Programmiersprachen vertreten. Eine Liste der unterstützten Sprachen finden Sie auf der Seite für Clientbibliotheken.

Java

Verwendet die Java-Clientbibliothek.

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

Verwendet die .NET-Clientbibliothek.

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

Verwendet die PHP-Clientbibliothek.

/**
 * 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

Verwendet die Python-Clientbibliothek.

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

Verwendet die Ruby-Clientbibliothek.

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

Ok

Verwendet die Go-Clientbibliothek.

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

Verwendet keine Clientbibliothek.

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