Contacts: patch

Requires authorization

Updates a contact in place. This method supports patch semantics. See an example.

Request

HTTP request

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

Parameters

Parameter name Value Description
Path parameters
id string The ID of the contact.

Authorization

This request requires authorization with the following scope (read more about authentication and authorization).

Scope
https://www.googleapis.com/auth/glass.timeline

Request body

In the request body, supply the relevant portions of a Contacts resource, according to the rules of patch semantics.

Response

If successful, this method returns a Contacts resource in the response body.

Examples

Note: The code examples available for this method do not represent all supported programming languages (see the client libraries page for a list of supported languages).

Java

Uses the Java client library.

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

import java.io.IOException;

public class MyClass {
  // ...

  /**
   * Rename an existing contact for the current user.
   * 
   * @param service Authorized Mirror service.
   * @param contactId ID of the contact to rename.
   * @param newDisplayName New displayName for the contact.
   * @return Patched contact on success, {@code null} otherwise.
   */
  public static Contact renameContact(Mirror service, String contactId, String newDisplayName) {
    Contact patchedContact = new Contact();
    patchedContact.setDisplayName(newDisplayName);

    try {
      return service.contacts().patch(contactId, patchedContact).execute();
    } catch (IOException e) {
      System.err.println("An error occurred: " + e);
      return null;
    }
  }

  // ...
}

.NET

Uses the .NET client library.

using System;

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

public class MyClass {
  // ...

  /// <summary>
  /// Rename an existing contact for the current user.
  /// </summary>
  /// <param name='service'>Authorized Mirror service.</param>
  /// <param name='contactId'>ID of the contact to rename.</param>
  /// <param name='newDisplayName'>
  /// New displayName for the contact.
  /// </param>
  /// <returns>
  /// Patched contact on success, null otherwise.
  /// </returns>
  public static Contact RenameContact(MirrorService service,
      String contactId, String newDisplayName) {
    Contact patchedContact = new Contact() {
      DisplayName = newDisplayName
    };
    try {
      return service.Contacts.Patch(
          patchedContact, contactId).Fetch();
    } catch (Exception e) {
      Console.WriteLine("An error occurred: " + e.Message);
      return null;
    }
  }

  // ...
}

PHP

Uses the PHP client library.

/**
 * Rename an existing contact for the current user.
 *
 * @param Google_MirrorService $service Authorized Mirror service.
 * @param string $contactId ID of the contact to rename.
 * @param string $newDisplayName New displayName for the contact.
 * @return Google_Contact Patched contact on success, null otherwise.
 */
function renameContact($service, $contactId, $newDisplayName) {
  try {
    $patchedContact = new Google_Contact();
    $patchedContact->setDisplayName($newDisplayName);
    return $service->contacts->patch($contactId, $patchedContact);
  } catch (Exception $e) {
    print 'An error occurred: ' . $e->getMessage();
    return null;
  }
}

Python

Uses the Python client library.

from apiclient import errors
# ...

def rename_contact(service, contact_id, new_display_name):
  """Rename an existing contact for the current user.

  Args:
    service: Authorized Mirror service.
    contact_id: ID of the contact to rename.
    new_display_name: New displayName for the contact.

  Returns:
    return Patched contact on success, None otherwise.
  """
  patched_contact = {'displayName': new_display_name}
  try:
    return service.contacts().patch(
        id=contact_id, body=patched_contact).execute()
  except errors.HttpError, error:
    print 'An error occurred: %s' % error
    return None

Ruby

Uses the Ruby client library.

##
# Rename an existing contact for the current user.
#
# @param [Google::APIClient] client
#   Authorized client instance.
# @param [String] contact_id
#   ID of the contact to rename.
# @param [String] new_display_name
#   New displayName for the contact.
# @return [Google::APIClient::Schema::Mirror::V1::Contact]
#   Patched contact on success, nil otherwise.
def rename_contact(client, contact_id, new_display_name)
  mirror = client.discovered_api('mirror', 'v1')
  patched_contact = mirror.contacts.patch.request_schema.new({
    'displayName' => new_display_name
  })
  result = client.execute(
    :api_method => mirror.contacts.patch,
    :parameters => { 'id' => contact_id },
    :body_object => contact)
  if result.success?
    return result.data
  else
    puts "An error occurred: #{result.data['error']['message']}"
  end
end

Go

Uses the Go client library.

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

// RenameContact renames an existing contact for the current user.
func RenameContact(g *mirror.Service, contactId string,
        newDisplayName string) (*mirror.Contact, error) {
        s := &mirror.Contact{DisplayName: newDisplayName}
        r, err := g.Contacts.Patch(contactId, s).Do()
        if err != nil {
                fmt.Printf("An error occurred: %v\n", err)
                return nil, err
        }
        return r, nil
}

Raw HTTP

Does not use a client library.

PATCH /mirror/v1/contacts/harold HTTP/1.1
Authorization: Bearer auth token
Content-Type: application/json
Content-Length: length

{
  "displayName": "Harold Penguin"
}