Crea eventos

Imagina una app que ayude a los usuarios a encontrar las mejores rutas de senderismo. Cuando se agrega el plan de senderismo como un evento de calendario, los usuarios reciben mucha ayuda para mantenerse organizados automáticamente. El Calendario de Google los ayuda a compartir el plan y a recordarlo para que puedan prepararse sin estrés. Además, gracias a la integración perfecta de los productos de Google, Google Now les envía un ping sobre la hora de salir y Google Maps los dirige al lugar de reunión a tiempo.

En este artículo, se explica cómo crear eventos de calendario y agregarlos a los calendarios de tus usuarios.

Agregar un evento

Para crear un evento, llama al método events.insert() y proporciona al menos estos parámetros:

• calendarId es el identificador del calendario y puede ser la dirección de correo electrónico del calendario en el que se creará el evento o una palabra clave especial 'primary' que usará el calendario principal del usuario que accedió. Si no conoces la dirección de correo electrónico del calendario que deseas usar, puedes verificarla en la configuración del calendario de la IU web del Calendario de Google (en la sección "Dirección del calendario") o buscarla en el resultado de la llamada calendarList.list().
• event es el evento que se creará con todos los detalles necesarios, como el inicio y el final. Los únicos dos campos obligatorios son los tiempos start y end. Consulta la referencia de event para obtener el conjunto completo de campos de eventos.
  Especifica eventos programados con los campos start.dateTime y end.dateTime. Para los eventos que duran todo el día, usa start.date y end.date en su lugar.

Para crear eventos correctamente, debes hacer lo siguiente:

• Establece el alcance de OAuth en https://www.googleapis.com/auth/calendar para que tengas acceso de edición al calendario del usuario.
• Asegúrate de que el usuario autenticado tenga acceso de escritura al calendario con el calendarId que proporcionaste (por ejemplo, llamando a calendarList.get() para el calendarId y verificando el accessRole).

Agrega metadatos de eventos

De forma opcional, puedes agregar metadatos de eventos cuando creas un evento de calendario. Si decides no agregar metadatos durante la creación, puedes actualizar muchos campos con events.update(). Sin embargo, algunos campos, como el ID del evento, solo se pueden establecer durante una operación events.insert().

Ubicación

Agregar una dirección al campo de ubicación habilita funciones como las siguientes:

"hora de salir" o mostrar un mapa con las instrucciones sobre cómo llegar.

ID de evento

Cuando creas un evento, puedes elegir generar tu propio ID de evento.

que cumpla con nuestros requisitos de formato. Esto te permite mantener las entidades de tu base de datos local sincronizadas con los eventos del Calendario de Google. También impide la creación de eventos duplicados si la operación falla en algún momento después de que se ejecuta correctamente en el backend de Calendario. Si no se proporciona un ID de evento, el servidor generará uno por ti. Consulta la referencia del ID de evento para obtener más información.

Participantes

El evento que crees aparecerá en todos los Calendarios de Google principales de

los asistentes que incluiste con el mismo ID de evento. Si configuras sendNotifications como true en tu solicitud de inserción, los asistentes también recibirán una notificación por correo electrónico sobre tu evento. Consulta la guía sobre eventos con varios asistentes para obtener más información.

En los siguientes ejemplos, se muestra cómo crear un evento y establecer sus metadatos:

Go

// Refer to the Go quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/go
// Change the scope to calendar.CalendarScope and delete any stored credentials.

event := &calendar.Event{
  Summary: "Google I/O 2015",
  Location: "800 Howard St., San Francisco, CA 94103",
  Description: "A chance to hear more about Google's developer products.",
  Start: &calendar.EventDateTime{
    DateTime: "2015-05-28T09:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  End: &calendar.EventDateTime{
    DateTime: "2015-05-28T17:00:00-07:00",
    TimeZone: "America/Los_Angeles",
  },
  Recurrence: []string{"RRULE:FREQ=DAILY;COUNT=2"},
  Attendees: []*calendar.EventAttendee{
    &calendar.EventAttendee{Email:"[e-mail]"},
    &calendar.EventAttendee{Email:"[e-mail]"},
  },
}

calendarId := "primary"
event, err = srv.Events.Insert(calendarId, event).Do()
if err != nil {
  log.Fatalf("Unable to create event. %v\n", err)
}
fmt.Printf("Event created: %s\n", event.HtmlLink)

Java

// Refer to the Java quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/java
// Change the scope to CalendarScopes.CALENDAR and delete any stored
// credentials.

Event event = new Event()
    .setSummary("Google I/O 2015")
    .setLocation("800 Howard St., San Francisco, CA 94103")
    .setDescription("A chance to hear more about Google's developer products.");

DateTime startDateTime = new DateTime("2015-05-28T09:00:00-07:00");
EventDateTime start = new EventDateTime()
    .setDateTime(startDateTime)
    .setTimeZone("America/Los_Angeles");
event.setStart(start);

DateTime endDateTime = new DateTime("2015-05-28T17:00:00-07:00");
EventDateTime end = new EventDateTime()
    .setDateTime(endDateTime)
    .setTimeZone("America/Los_Angeles");
event.setEnd(end);

String[] recurrence = new String[] {"RRULE:FREQ=DAILY;COUNT=2"};
event.setRecurrence(Arrays.asList(recurrence));

EventAttendee[] attendees = new EventAttendee[] {
    new EventAttendee().setEmail("[e-mail]"),
    new EventAttendee().setEmail("[e-mail]"),
};
event.setAttendees(Arrays.asList(attendees));

EventReminder[] reminderOverrides = new EventReminder[] {
    new EventReminder().setMethod("email").setMinutes(24 * 60),
    new EventReminder().setMethod("popup").setMinutes(10),
};
Event.Reminders reminders = new Event.Reminders()
    .setUseDefault(false)
    .setOverrides(Arrays.asList(reminderOverrides));
event.setReminders(reminders);

String calendarId = "primary";
event = service.events().insert(calendarId, event).execute();
System.out.printf("Event created: %s\n", event.getHtmlLink());

JavaScript

// Refer to the JavaScript quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/js
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles'
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'}
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10}
    ]
  }
};

const request = gapi.client.calendar.events.insert({
  'calendarId': 'primary',
  'resource': event
});

request.execute(function(event) {
  appendPre('Event created: ' + event.htmlLink);
});

Node.js

// Refer to the Node.js quickstart on how to setup the environment:
// https://developers.google.com/calendar/quickstart/node
// Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
// stored credentials.

const event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': false,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
};

calendar.events.insert({
  auth: auth,
  calendarId: 'primary',
  resource: event,
}, function(err, event) {
  if (err) {
    console.log('There was an error contacting the Calendar service: ' + err);
    return;
  }
  console.log('Event created: %s', event.htmlLink);
});

PHP

$event = new Google_Service_Calendar_Event(array(
  'summary' => 'Google I/O 2015',
  'location' => '800 Howard St., San Francisco, CA 94103',
  'description' => 'A chance to hear more about Google\'s developer products.',
  'start' => array(
    'dateTime' => '2015-05-28T09:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'end' => array(
    'dateTime' => '2015-05-28T17:00:00-07:00',
    'timeZone' => 'America/Los_Angeles',
  ),
  'recurrence' => array(
    'RRULE:FREQ=DAILY;COUNT=2'
  ),
  'attendees' => array(
    array('email' => '[e-mail]'),
    array('email' => '[e-mail]'),
  ),
  'reminders' => array(
    'useDefault' => FALSE,
    'overrides' => array(
      array('method' => 'email', 'minutes' => 24 * 60),
      array('method' => 'popup', 'minutes' => 10),
    ),
  ),
));

$calendarId = 'primary';
$event = $service->events->insert($calendarId, $event);
printf('Event created: %s\n', $event->htmlLink);

Python

# Refer to the Python quickstart on how to setup the environment:
# https://developers.google.com/calendar/quickstart/python
# Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
# stored credentials.

event = {
  'summary': 'Google I/O 2015',
  'location': '800 Howard St., San Francisco, CA 94103',
  'description': 'A chance to hear more about Google\'s developer products.',
  'start': {
    'dateTime': '2015-05-28T09:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'end': {
    'dateTime': '2015-05-28T17:00:00-07:00',
    'timeZone': 'America/Los_Angeles',
  },
  'recurrence': [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  'attendees': [
    {'email': '[e-mail]'},
    {'email': '[e-mail]'},
  ],
  'reminders': {
    'useDefault': False,
    'overrides': [
      {'method': 'email', 'minutes': 24 * 60},
      {'method': 'popup', 'minutes': 10},
    ],
  },
}

event = service.events().insert(calendarId='primary', body=event).execute()
print 'Event created: %s' % (event.get('htmlLink'))

Ruby

event = Google::Apis::CalendarV3::Event.new(
  summary: 'Google I/O 2015',
  location: '800 Howard St., San Francisco, CA 94103',
  description: 'A chance to hear more about Google\'s developer products.',
  start: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T09:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  end: Google::Apis::CalendarV3::EventDateTime.new(
    date_time: '2015-05-28T17:00:00-07:00',
    time_zone: 'America/Los_Angeles'
  ),
  recurrence: [
    'RRULE:FREQ=DAILY;COUNT=2'
  ],
  attendees: [
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    ),
    Google::Apis::CalendarV3::EventAttendee.new(
      email: '[e-mail]'
    )
  ],
  reminders: Google::Apis::CalendarV3::Event::Reminders.new(
    use_default: false,
    overrides: [
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'email',
        minutes: 24 * 60
      ),
      Google::Apis::CalendarV3::EventReminder.new(
        reminder_method: 'popup',
        minutes: 10
      )
    ]
  )
)

result = client.insert_event('primary', event)
puts "Event created: #{result.html_link}"

Cómo agregar archivos adjuntos de Drive a eventos

Puedes adjuntar archivos de Google Drive, como notas de reuniones en Documentos, presupuestos en Hojas de cálculo, presentaciones en Presentaciones o cualquier otro archivo relevante de Google Drive a tus eventos de calendario. Puedes agregar el archivo adjunto cuando creas un evento con events.insert() o versiones posteriores como parte de una actualización, como con events.patch().

Las dos partes para adjuntar un archivo de Google Drive a un evento son las siguientes:

1. Obtén la URL de alternateLink, title y mimeType del recurso Archivos de la API de Drive, por lo general, con el método files.get().
2. Crea o actualiza un evento con los campos attachments establecidos en el cuerpo de la solicitud y el parámetro supportsAttachments establecido en true.

En el siguiente ejemplo de código, se muestra cómo actualizar un evento existente para agregar un archivo adjunto:

Java

public static void addAttachment(Calendar calendarService, Drive driveService, String calendarId,
    String eventId, String fileId) throws IOException {
  File file = driveService.files().get(fileId).execute();
  Event event = calendarService.events().get(calendarId, eventId).execute();

  List<EventAttachment> attachments = event.getAttachments();
  if (attachments == null) {
    attachments = new ArrayList<EventAttachment>();
  }
  attachments.add(new EventAttachment()
      .setFileUrl(file.getAlternateLink())
      .setMimeType(file.getMimeType())
      .setTitle(file.getTitle()));

  Event changes = new Event()
      .setAttachments(attachments);
  calendarService.events().patch(calendarId, eventId, changes)
      .setSupportsAttachments(true)
      .execute();
}

PHP

function addAttachment($calendarService, $driveService, $calendarId, $eventId, $fileId) {
  $file = $driveService->files->get($fileId);
  $event = $calendarService->events->get($calendarId, $eventId);
  $attachments = $event->attachments;

  $attachments[] = array(
    'fileUrl' => $file->alternateLink,
    'mimeType' => $file->mimeType,
    'title' => $file->title
  );
  $changes = new Google_Service_Calendar_Event(array(
    'attachments' => $attachments
  ));

  $calendarService->events->patch($calendarId, $eventId, $changes, array(
    'supportsAttachments' => TRUE
  ));
}

Python

def add_attachment(calendarService, driveService, calendarId, eventId, fileId):
    file = driveService.files().get(fileId=fileId).execute()
    event = calendarService.events().get(calendarId=calendarId,
                                         eventId=eventId).execute()

    attachments = event.get('attachments', [])
    attachments.append({
        'fileUrl': file['alternateLink'],
        'mimeType': file['mimeType'],
        'title': file['title']
    })

    changes = {
        'attachments': attachments
    }
    calendarService.events().patch(calendarId=calendarId, eventId=eventId,
                                   body=changes,
                                   supportsAttachments=True).execute()

Importante: Debes realizar una sincronización completa de todos los eventos antes de habilitar el parámetro supportsAttachments para las modificaciones de eventos cuando agregues compatibilidad con archivos adjuntos a tu app existente que almacena eventos de forma local. Si no realizas una sincronización primero, es posible que quites, de forma inadvertida, los archivos adjuntos existentes de los eventos del usuario.

Agrega reuniones de video y telefónicas a los eventos

Puedes asociar eventos con conferencias de Hangouts y Google Meet para permitir que tus usuarios se reúnan de forma remota por teléfono o videollamada.

El campo conferenceData se puede usar para leer, copiar y borrar los detalles de las conferencias existentes. También se puede usar para solicitar la generación de conferencias nuevas. Para permitir la creación y modificación de los detalles de la conferencia, establece el parámetro de solicitud conferenceDataVersion en 1.

Actualmente, se admiten tres tipos de conferenceData, como se indica en conferenceData.conferenceSolution.key.type:

1. Hangouts para consumidores (eventHangout)
2. Versión clásica de Hangouts para usuarios de Google Workspace (obsoleto; eventNamedHangout)
3. Google Meet (hangoutsMeet)

Para saber qué tipo de conferencia es compatible con cualquier calendario de un usuario, puedes consultar el conferenceProperties.allowedConferenceSolutionTypes en las colecciones calendars y calendarList. También puedes verificar si el usuario prefiere que se creen Hangouts para todos sus eventos recién creados. Para ello, consulta el parámetro de configuración autoAddHangouts en la colección settings.

Además de type, conferenceSolution también proporciona los campos name y iconUri que puedes usar para representar la solución de conferencia, como se muestra a continuación:

JavaScript

const solution = event.conferenceData.conferenceSolution;

const content = document.getElementById("content");
const text = document.createTextNode("Join " + solution.name);
const icon = document.createElement("img");
icon.src = solution.iconUri;

content.appendChild(icon);
content.appendChild(text);

Para crear una conferencia nueva para un evento, proporciona un createRequest con un requestId generado recientemente, que puede ser un string aleatorio. Las conferencias se crean de forma asíncrona, pero siempre puedes verificar el estado de tu solicitud para informar a los usuarios lo que sucede.

Por ejemplo, para solicitar la generación de una conferencia para un evento existente, sigue estos pasos:

JavaScript

const eventPatch = {
  conferenceData: {
    createRequest: {requestId: "7qxalsvy0e"}
  }
};

gapi.client.calendar.events.patch({
  calendarId: "primary",
  eventId: "7cbh8rpc10lrc0ckih9tafss99",
  resource: eventPatch,
  sendNotifications: true,
  conferenceDataVersion: 1
}).execute(function(event) {
  console.log("Conference created for event: %s", event.htmlLink);
});

Es posible que la respuesta inmediata a esta llamada aún no contenga el conferenceData completamente propagado. Esto se indica con un código de estado pending en el campo status. El código de estado cambia a success después de que se propaga la información de la conferencia. El campo entryPoints contiene información sobre qué URIs de video y teléfono están disponibles para que los usuarios marquen.

Si deseas programar varios eventos de Calendario con los mismos detalles de la conferencia, puedes copiar todo el conferenceData de un evento a otro.

La copia es útil en ciertas situaciones. Por ejemplo, supongamos que estás desarrollando una aplicación de reclutamiento que configura eventos separados para el candidato y el entrevistador. Quieres proteger la identidad del entrevistador, pero también quieres asegurarte de que todos los participantes se unan a la misma conferencia telefónica.

Importante: Debes realizar una sincronización completa de todos los eventos antes de habilitar la compatibilidad con los datos de conferencias (configurando el parámetro de solicitud conferenceDataVersion en 1 para las modificaciones de eventos) cuando agregues compatibilidad con conferencias a tu app existente que almacena eventos de forma local. Si primero no realizas una sincronización, es posible que quites, de forma inadvertida, conferencias existentes de los eventos de los usuarios.